| | """ |
| | A MathML printer. |
| | """ |
| |
|
| | from __future__ import annotations |
| | from typing import Any |
| |
|
| | from sympy.core.mul import Mul |
| | from sympy.core.singleton import S |
| | from sympy.core.sorting import default_sort_key |
| | from sympy.core.sympify import sympify |
| | from sympy.printing.conventions import split_super_sub, requires_partial |
| | from sympy.printing.precedence import \ |
| | precedence_traditional, PRECEDENCE, PRECEDENCE_TRADITIONAL |
| | from sympy.printing.pretty.pretty_symbology import greek_unicode |
| | from sympy.printing.printer import Printer, print_function |
| |
|
| | from mpmath.libmp import prec_to_dps, repr_dps, to_str as mlib_to_str |
| |
|
| |
|
| | class MathMLPrinterBase(Printer): |
| | """Contains common code required for MathMLContentPrinter and |
| | MathMLPresentationPrinter. |
| | """ |
| |
|
| | _default_settings: dict[str, Any] = { |
| | "order": None, |
| | "encoding": "utf-8", |
| | "fold_frac_powers": False, |
| | "fold_func_brackets": False, |
| | "fold_short_frac": None, |
| | "inv_trig_style": "abbreviated", |
| | "ln_notation": False, |
| | "long_frac_ratio": None, |
| | "mat_delim": "[", |
| | "mat_symbol_style": "plain", |
| | "mul_symbol": None, |
| | "root_notation": True, |
| | "symbol_names": {}, |
| | "mul_symbol_mathml_numbers": '·', |
| | "disable_split_super_sub": False, |
| | } |
| |
|
| | def __init__(self, settings=None): |
| | Printer.__init__(self, settings) |
| | from xml.dom.minidom import Document, Text |
| |
|
| | self.dom = Document() |
| |
|
| | |
| | |
| | |
| | |
| | class RawText(Text): |
| | def writexml(self, writer, indent='', addindent='', newl=''): |
| | if self.data: |
| | writer.write('{}{}{}'.format(indent, self.data, newl)) |
| |
|
| | def createRawTextNode(data): |
| | r = RawText() |
| | r.data = data |
| | r.ownerDocument = self.dom |
| | return r |
| |
|
| | self.dom.createTextNode = createRawTextNode |
| |
|
| | def doprint(self, expr): |
| | """ |
| | Prints the expression as MathML. |
| | """ |
| | mathML = Printer._print(self, expr) |
| | unistr = mathML.toxml() |
| | xmlbstr = unistr.encode('ascii', 'xmlcharrefreplace') |
| | res = xmlbstr.decode() |
| | return res |
| |
|
| | def _split_super_sub(self, name): |
| | if self._settings["disable_split_super_sub"]: |
| | return (name, [], []) |
| | else: |
| | return split_super_sub(name) |
| |
|
| |
|
| | class MathMLContentPrinter(MathMLPrinterBase): |
| | """Prints an expression to the Content MathML markup language. |
| | |
| | References: https://www.w3.org/TR/MathML2/chapter4.html |
| | """ |
| | printmethod = "_mathml_content" |
| |
|
| | def mathml_tag(self, e): |
| | """Returns the MathML tag for an expression.""" |
| | translate = { |
| | 'Add': 'plus', |
| | 'Mul': 'times', |
| | 'Derivative': 'diff', |
| | 'Number': 'cn', |
| | 'int': 'cn', |
| | 'Pow': 'power', |
| | 'Max': 'max', |
| | 'Min': 'min', |
| | 'Abs': 'abs', |
| | 'And': 'and', |
| | 'Or': 'or', |
| | 'Xor': 'xor', |
| | 'Not': 'not', |
| | 'Implies': 'implies', |
| | 'Symbol': 'ci', |
| | 'MatrixSymbol': 'ci', |
| | 'RandomSymbol': 'ci', |
| | 'Integral': 'int', |
| | 'Sum': 'sum', |
| | 'sin': 'sin', |
| | 'cos': 'cos', |
| | 'tan': 'tan', |
| | 'cot': 'cot', |
| | 'csc': 'csc', |
| | 'sec': 'sec', |
| | 'sinh': 'sinh', |
| | 'cosh': 'cosh', |
| | 'tanh': 'tanh', |
| | 'coth': 'coth', |
| | 'csch': 'csch', |
| | 'sech': 'sech', |
| | 'asin': 'arcsin', |
| | 'asinh': 'arcsinh', |
| | 'acos': 'arccos', |
| | 'acosh': 'arccosh', |
| | 'atan': 'arctan', |
| | 'atanh': 'arctanh', |
| | 'atan2': 'arctan', |
| | 'acot': 'arccot', |
| | 'acoth': 'arccoth', |
| | 'asec': 'arcsec', |
| | 'asech': 'arcsech', |
| | 'acsc': 'arccsc', |
| | 'acsch': 'arccsch', |
| | 'log': 'ln', |
| | 'Equality': 'eq', |
| | 'Unequality': 'neq', |
| | 'GreaterThan': 'geq', |
| | 'LessThan': 'leq', |
| | 'StrictGreaterThan': 'gt', |
| | 'StrictLessThan': 'lt', |
| | 'Union': 'union', |
| | 'Intersection': 'intersect', |
| | } |
| |
|
| | for cls in e.__class__.__mro__: |
| | n = cls.__name__ |
| | if n in translate: |
| | return translate[n] |
| | |
| | n = e.__class__.__name__ |
| | return n.lower() |
| |
|
| | def _print_Mul(self, expr): |
| |
|
| | if expr.could_extract_minus_sign(): |
| | 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: |
| | |
| | |
| | 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 _print_Add(self, expr, order=None): |
| | args = self._as_ordered_terms(expr, order=order) |
| | lastProcessed = self._print(args[0]) |
| | plusNodes = [] |
| | for arg in args[1:]: |
| | if arg.could_extract_minus_sign(): |
| | |
| | x = self.dom.createElement('apply') |
| | x.appendChild(self.dom.createElement('minus')) |
| | x.appendChild(lastProcessed) |
| | x.appendChild(self._print(-arg)) |
| | |
| | lastProcessed = x |
| | if arg == args[-1]: |
| | plusNodes.append(lastProcessed) |
| | else: |
| | plusNodes.append(lastProcessed) |
| | lastProcessed = self._print(arg) |
| | if arg == args[-1]: |
| | plusNodes.append(self._print(arg)) |
| | if len(plusNodes) == 1: |
| | return lastProcessed |
| | x = self.dom.createElement('apply') |
| | x.appendChild(self.dom.createElement('plus')) |
| | while plusNodes: |
| | x.appendChild(plusNodes.pop(0)) |
| | return x |
| |
|
| | def _print_Piecewise(self, expr): |
| | if expr.args[-1].cond != True: |
| | |
| | |
| | raise ValueError("All Piecewise expressions must contain an " |
| | "(expr, True) statement to be used as a default " |
| | "condition. Without one, the generated " |
| | "expression may not evaluate to anything under " |
| | "some condition.") |
| | root = self.dom.createElement('piecewise') |
| | for i, (e, c) in enumerate(expr.args): |
| | if i == len(expr.args) - 1 and c == True: |
| | piece = self.dom.createElement('otherwise') |
| | piece.appendChild(self._print(e)) |
| | else: |
| | piece = self.dom.createElement('piece') |
| | piece.appendChild(self._print(e)) |
| | piece.appendChild(self._print(c)) |
| | root.appendChild(piece) |
| | return root |
| |
|
| | def _print_MatrixBase(self, m): |
| | x = self.dom.createElement('matrix') |
| | for i in range(m.rows): |
| | x_r = self.dom.createElement('matrixrow') |
| | for j in range(m.cols): |
| | x_r.appendChild(self._print(m[i, j])) |
| | x.appendChild(x_r) |
| | return x |
| |
|
| | def _print_Rational(self, e): |
| | if e.q == 1: |
| | |
| | x = self.dom.createElement('cn') |
| | x.appendChild(self.dom.createTextNode(str(e.p))) |
| | return x |
| | x = self.dom.createElement('apply') |
| | x.appendChild(self.dom.createElement('divide')) |
| | |
| | xnum = self.dom.createElement('cn') |
| | xnum.appendChild(self.dom.createTextNode(str(e.p))) |
| | |
| | xdenom = self.dom.createElement('cn') |
| | xdenom.appendChild(self.dom.createTextNode(str(e.q))) |
| | x.appendChild(xnum) |
| | x.appendChild(xdenom) |
| | return x |
| |
|
| | def _print_Limit(self, e): |
| | x = self.dom.createElement('apply') |
| | x.appendChild(self.dom.createElement(self.mathml_tag(e))) |
| |
|
| | x_1 = self.dom.createElement('bvar') |
| | x_2 = self.dom.createElement('lowlimit') |
| | x_1.appendChild(self._print(e.args[1])) |
| | x_2.appendChild(self._print(e.args[2])) |
| |
|
| | x.appendChild(x_1) |
| | x.appendChild(x_2) |
| | x.appendChild(self._print(e.args[0])) |
| | return x |
| |
|
| | def _print_ImaginaryUnit(self, e): |
| | return self.dom.createElement('imaginaryi') |
| |
|
| | def _print_EulerGamma(self, e): |
| | return self.dom.createElement('eulergamma') |
| |
|
| | def _print_GoldenRatio(self, e): |
| | """We use unicode #x3c6 for Greek letter phi as defined here |
| | https://www.w3.org/2003/entities/2007doc/isogrk1.html""" |
| | x = self.dom.createElement('cn') |
| | x.appendChild(self.dom.createTextNode("\N{GREEK SMALL LETTER PHI}")) |
| | return x |
| |
|
| | def _print_Exp1(self, e): |
| | return self.dom.createElement('exponentiale') |
| |
|
| | def _print_Pi(self, e): |
| | return self.dom.createElement('pi') |
| |
|
| | def _print_Infinity(self, e): |
| | return self.dom.createElement('infinity') |
| |
|
| | def _print_NaN(self, e): |
| | return self.dom.createElement('notanumber') |
| |
|
| | def _print_EmptySet(self, e): |
| | return self.dom.createElement('emptyset') |
| |
|
| | def _print_BooleanTrue(self, e): |
| | return self.dom.createElement('true') |
| |
|
| | def _print_BooleanFalse(self, e): |
| | return self.dom.createElement('false') |
| |
|
| | def _print_NegativeInfinity(self, e): |
| | x = self.dom.createElement('apply') |
| | x.appendChild(self.dom.createElement('minus')) |
| | x.appendChild(self.dom.createElement('infinity')) |
| | return x |
| |
|
| | def _print_Integral(self, e): |
| | def lime_recur(limits): |
| | x = self.dom.createElement('apply') |
| | x.appendChild(self.dom.createElement(self.mathml_tag(e))) |
| | bvar_elem = self.dom.createElement('bvar') |
| | bvar_elem.appendChild(self._print(limits[0][0])) |
| | x.appendChild(bvar_elem) |
| |
|
| | if len(limits[0]) == 3: |
| | low_elem = self.dom.createElement('lowlimit') |
| | low_elem.appendChild(self._print(limits[0][1])) |
| | x.appendChild(low_elem) |
| | up_elem = self.dom.createElement('uplimit') |
| | up_elem.appendChild(self._print(limits[0][2])) |
| | x.appendChild(up_elem) |
| | if len(limits[0]) == 2: |
| | up_elem = self.dom.createElement('uplimit') |
| | up_elem.appendChild(self._print(limits[0][1])) |
| | x.appendChild(up_elem) |
| | if len(limits) == 1: |
| | x.appendChild(self._print(e.function)) |
| | else: |
| | x.appendChild(lime_recur(limits[1:])) |
| | return x |
| |
|
| | limits = list(e.limits) |
| | limits.reverse() |
| | return lime_recur(limits) |
| |
|
| | def _print_Sum(self, e): |
| | |
| | |
| | return self._print_Integral(e) |
| |
|
| | def _print_Symbol(self, sym): |
| | ci = self.dom.createElement(self.mathml_tag(sym)) |
| |
|
| | def join(items): |
| | if len(items) > 1: |
| | mrow = self.dom.createElement('mml:mrow') |
| | for i, item in enumerate(items): |
| | if i > 0: |
| | mo = self.dom.createElement('mml:mo') |
| | mo.appendChild(self.dom.createTextNode(" ")) |
| | mrow.appendChild(mo) |
| | mi = self.dom.createElement('mml:mi') |
| | mi.appendChild(self.dom.createTextNode(item)) |
| | mrow.appendChild(mi) |
| | return mrow |
| | else: |
| | mi = self.dom.createElement('mml:mi') |
| | mi.appendChild(self.dom.createTextNode(items[0])) |
| | return mi |
| |
|
| | |
| | def translate(s): |
| | if s in greek_unicode: |
| | return greek_unicode.get(s) |
| | else: |
| | return s |
| |
|
| | name, supers, subs = self._split_super_sub(sym.name) |
| | name = translate(name) |
| | supers = [translate(sup) for sup in supers] |
| | subs = [translate(sub) for sub in subs] |
| |
|
| | mname = self.dom.createElement('mml:mi') |
| | mname.appendChild(self.dom.createTextNode(name)) |
| | if not supers: |
| | if not subs: |
| | ci.appendChild(self.dom.createTextNode(name)) |
| | else: |
| | msub = self.dom.createElement('mml:msub') |
| | msub.appendChild(mname) |
| | msub.appendChild(join(subs)) |
| | ci.appendChild(msub) |
| | else: |
| | if not subs: |
| | msup = self.dom.createElement('mml:msup') |
| | msup.appendChild(mname) |
| | msup.appendChild(join(supers)) |
| | ci.appendChild(msup) |
| | else: |
| | msubsup = self.dom.createElement('mml:msubsup') |
| | msubsup.appendChild(mname) |
| | msubsup.appendChild(join(subs)) |
| | msubsup.appendChild(join(supers)) |
| | ci.appendChild(msubsup) |
| | return ci |
| |
|
| | _print_MatrixSymbol = _print_Symbol |
| | _print_RandomSymbol = _print_Symbol |
| |
|
| | def _print_Pow(self, e): |
| | |
| | |
| | if (self._settings['root_notation'] and e.exp.is_Rational |
| | and e.exp.p == 1): |
| | x = self.dom.createElement('apply') |
| | x.appendChild(self.dom.createElement('root')) |
| | if e.exp.q != 2: |
| | xmldeg = self.dom.createElement('degree') |
| | xmlcn = self.dom.createElement('cn') |
| | xmlcn.appendChild(self.dom.createTextNode(str(e.exp.q))) |
| | xmldeg.appendChild(xmlcn) |
| | x.appendChild(xmldeg) |
| | x.appendChild(self._print(e.base)) |
| | return x |
| |
|
| | x = self.dom.createElement('apply') |
| | x_1 = self.dom.createElement(self.mathml_tag(e)) |
| | x.appendChild(x_1) |
| | x.appendChild(self._print(e.base)) |
| | x.appendChild(self._print(e.exp)) |
| | return x |
| |
|
| | def _print_Number(self, e): |
| | x = self.dom.createElement(self.mathml_tag(e)) |
| | x.appendChild(self.dom.createTextNode(str(e))) |
| | return x |
| |
|
| | def _print_Float(self, e): |
| | x = self.dom.createElement(self.mathml_tag(e)) |
| | repr_e = mlib_to_str(e._mpf_, repr_dps(e._prec)) |
| | x.appendChild(self.dom.createTextNode(repr_e)) |
| | return x |
| |
|
| | def _print_Derivative(self, e): |
| | x = self.dom.createElement('apply') |
| | diff_symbol = self.mathml_tag(e) |
| | if requires_partial(e.expr): |
| | diff_symbol = 'partialdiff' |
| | x.appendChild(self.dom.createElement(diff_symbol)) |
| | x_1 = self.dom.createElement('bvar') |
| |
|
| | for sym, times in reversed(e.variable_count): |
| | x_1.appendChild(self._print(sym)) |
| | if times > 1: |
| | degree = self.dom.createElement('degree') |
| | degree.appendChild(self._print(sympify(times))) |
| | x_1.appendChild(degree) |
| |
|
| | x.appendChild(x_1) |
| | x.appendChild(self._print(e.expr)) |
| | return x |
| |
|
| | def _print_Function(self, e): |
| | x = self.dom.createElement("apply") |
| | x.appendChild(self.dom.createElement(self.mathml_tag(e))) |
| | for arg in e.args: |
| | x.appendChild(self._print(arg)) |
| | return x |
| |
|
| | def _print_Basic(self, e): |
| | x = self.dom.createElement(self.mathml_tag(e)) |
| | for arg in e.args: |
| | x.appendChild(self._print(arg)) |
| | return x |
| |
|
| | def _print_AssocOp(self, e): |
| | x = self.dom.createElement('apply') |
| | x_1 = self.dom.createElement(self.mathml_tag(e)) |
| | x.appendChild(x_1) |
| | for arg in e.args: |
| | x.appendChild(self._print(arg)) |
| | return x |
| |
|
| | def _print_Relational(self, e): |
| | x = self.dom.createElement('apply') |
| | x.appendChild(self.dom.createElement(self.mathml_tag(e))) |
| | x.appendChild(self._print(e.lhs)) |
| | x.appendChild(self._print(e.rhs)) |
| | return x |
| |
|
| | def _print_list(self, seq): |
| | """MathML reference for the <list> element: |
| | https://www.w3.org/TR/MathML2/chapter4.html#contm.list""" |
| | dom_element = self.dom.createElement('list') |
| | for item in seq: |
| | dom_element.appendChild(self._print(item)) |
| | return dom_element |
| |
|
| | def _print_int(self, p): |
| | dom_element = self.dom.createElement(self.mathml_tag(p)) |
| | dom_element.appendChild(self.dom.createTextNode(str(p))) |
| | return dom_element |
| |
|
| | _print_Implies = _print_AssocOp |
| | _print_Not = _print_AssocOp |
| | _print_Xor = _print_AssocOp |
| |
|
| | def _print_FiniteSet(self, e): |
| | x = self.dom.createElement('set') |
| | for arg in e.args: |
| | x.appendChild(self._print(arg)) |
| | return x |
| |
|
| | def _print_Complement(self, e): |
| | x = self.dom.createElement('apply') |
| | x.appendChild(self.dom.createElement('setdiff')) |
| | for arg in e.args: |
| | x.appendChild(self._print(arg)) |
| | return x |
| |
|
| | def _print_ProductSet(self, e): |
| | x = self.dom.createElement('apply') |
| | x.appendChild(self.dom.createElement('cartesianproduct')) |
| | for arg in e.args: |
| | x.appendChild(self._print(arg)) |
| | return x |
| |
|
| | def _print_Lambda(self, e): |
| | |
| | |
| | x = self.dom.createElement(self.mathml_tag(e)) |
| | for arg in e.signature: |
| | x_1 = self.dom.createElement('bvar') |
| | x_1.appendChild(self._print(arg)) |
| | x.appendChild(x_1) |
| | x.appendChild(self._print(e.expr)) |
| | return x |
| |
|
| | |
| |
|
| |
|
| | class MathMLPresentationPrinter(MathMLPrinterBase): |
| | """Prints an expression to the Presentation MathML markup language. |
| | |
| | References: https://www.w3.org/TR/MathML2/chapter3.html |
| | """ |
| | printmethod = "_mathml_presentation" |
| |
|
| | def mathml_tag(self, e): |
| | """Returns the MathML tag for an expression.""" |
| | translate = { |
| | 'Number': 'mn', |
| | 'Limit': '→', |
| | 'Derivative': 'ⅆ', |
| | 'int': 'mn', |
| | 'Symbol': 'mi', |
| | 'Integral': '∫', |
| | 'Sum': '∑', |
| | 'sin': 'sin', |
| | 'cos': 'cos', |
| | 'tan': 'tan', |
| | 'cot': 'cot', |
| | 'asin': 'arcsin', |
| | 'asinh': 'arcsinh', |
| | 'acos': 'arccos', |
| | 'acosh': 'arccosh', |
| | 'atan': 'arctan', |
| | 'atanh': 'arctanh', |
| | 'acot': 'arccot', |
| | 'atan2': 'arctan', |
| | 'Equality': '=', |
| | 'Unequality': '≠', |
| | 'GreaterThan': '≥', |
| | 'LessThan': '≤', |
| | 'StrictGreaterThan': '>', |
| | 'StrictLessThan': '<', |
| | 'lerchphi': 'Φ', |
| | 'zeta': 'ζ', |
| | 'dirichlet_eta': 'η', |
| | 'elliptic_k': 'Κ', |
| | 'lowergamma': 'γ', |
| | 'uppergamma': 'Γ', |
| | 'gamma': 'Γ', |
| | 'totient': 'ϕ', |
| | 'reduced_totient': 'λ', |
| | 'primenu': 'ν', |
| | 'primeomega': 'Ω', |
| | 'fresnels': 'S', |
| | 'fresnelc': 'C', |
| | 'LambertW': 'W', |
| | 'Heaviside': 'Θ', |
| | 'BooleanTrue': 'True', |
| | 'BooleanFalse': 'False', |
| | 'NoneType': 'None', |
| | 'mathieus': 'S', |
| | 'mathieuc': 'C', |
| | 'mathieusprime': 'S′', |
| | 'mathieucprime': 'C′', |
| | 'Lambda': 'lambda', |
| | } |
| |
|
| | def mul_symbol_selection(): |
| | if (self._settings["mul_symbol"] is None or |
| | self._settings["mul_symbol"] == 'None'): |
| | return '⁢' |
| | elif self._settings["mul_symbol"] == 'times': |
| | return '×' |
| | elif self._settings["mul_symbol"] == 'dot': |
| | return '·' |
| | elif self._settings["mul_symbol"] == 'ldot': |
| | return '․' |
| | elif not isinstance(self._settings["mul_symbol"], str): |
| | raise TypeError |
| | else: |
| | return self._settings["mul_symbol"] |
| | for cls in e.__class__.__mro__: |
| | n = cls.__name__ |
| | if n in translate: |
| | return translate[n] |
| | |
| | if e.__class__.__name__ == "Mul": |
| | return mul_symbol_selection() |
| | n = e.__class__.__name__ |
| | return n.lower() |
| |
|
| | def _l_paren(self): |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('(')) |
| | return mo |
| |
|
| | def _r_paren(self): |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode(')')) |
| | return mo |
| |
|
| | def _l_brace(self): |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('{')) |
| | return mo |
| |
|
| | def _r_brace(self): |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('}')) |
| | return mo |
| |
|
| | def _comma(self): |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode(',')) |
| | return mo |
| |
|
| | def _bar(self): |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('|')) |
| | return mo |
| |
|
| | def _semicolon(self): |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode(';')) |
| | return mo |
| |
|
| | def _paren_comma_separated(self, *args): |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(self._l_paren()) |
| | for i, arg in enumerate(args): |
| | if i: |
| | mrow.appendChild(self._comma()) |
| | mrow.appendChild(self._print(arg)) |
| | mrow.appendChild(self._r_paren()) |
| | return mrow |
| |
|
| | def _paren_bar_separated(self, *args): |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(self._l_paren()) |
| | for i, arg in enumerate(args): |
| | if i: |
| | mrow.appendChild(self._bar()) |
| | mrow.appendChild(self._print(arg)) |
| | mrow.appendChild(self._r_paren()) |
| | return mrow |
| |
|
| | def parenthesize(self, item, level, strict=False): |
| | prec_val = precedence_traditional(item) |
| | if (prec_val < level) or ((not strict) and prec_val <= level): |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(self._l_paren()) |
| | mrow.appendChild(self._print(item)) |
| | mrow.appendChild(self._r_paren()) |
| | return mrow |
| | return self._print(item) |
| |
|
| | def _print_Mul(self, expr): |
| |
|
| | 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: |
| | mrow.appendChild(self.parenthesize(term, PRECEDENCE['Mul'])) |
| | if not term == terms[-1]: |
| | y = self.dom.createElement('mo') |
| | y.appendChild(self.dom.createTextNode(self.mathml_tag(expr))) |
| | mrow.appendChild(y) |
| | return mrow |
| | mrow = self.dom.createElement('mrow') |
| | if expr.could_extract_minus_sign(): |
| | x = self.dom.createElement('mo') |
| | x.appendChild(self.dom.createTextNode('-')) |
| | mrow.appendChild(x) |
| | mrow = multiply(-expr, mrow) |
| | else: |
| | mrow = multiply(expr, mrow) |
| |
|
| | return mrow |
| |
|
| | def _print_Add(self, expr, order=None): |
| | mrow = self.dom.createElement('mrow') |
| | args = self._as_ordered_terms(expr, order=order) |
| | mrow.appendChild(self._print(args[0])) |
| | for arg in args[1:]: |
| | if arg.could_extract_minus_sign(): |
| | |
| | x = self.dom.createElement('mo') |
| | x.appendChild(self.dom.createTextNode('-')) |
| | y = self._print(-arg) |
| | |
| | else: |
| | x = self.dom.createElement('mo') |
| | x.appendChild(self.dom.createTextNode('+')) |
| | y = self._print(arg) |
| | mrow.appendChild(x) |
| | mrow.appendChild(y) |
| |
|
| | return mrow |
| |
|
| | def _print_MatrixBase(self, m): |
| | table = self.dom.createElement('mtable') |
| | for i in range(m.rows): |
| | x = self.dom.createElement('mtr') |
| | for j in range(m.cols): |
| | y = self.dom.createElement('mtd') |
| | y.appendChild(self._print(m[i, j])) |
| | x.appendChild(y) |
| | table.appendChild(x) |
| | mat_delim = self._settings["mat_delim"] |
| | if mat_delim == '': |
| | return table |
| | left = self.dom.createElement('mo') |
| | right = self.dom.createElement('mo') |
| | if mat_delim == "[": |
| | left.appendChild(self.dom.createTextNode("[")) |
| | right.appendChild(self.dom.createTextNode("]")) |
| | else: |
| | left.appendChild(self.dom.createTextNode("(")) |
| | right.appendChild(self.dom.createTextNode(")")) |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(left) |
| | mrow.appendChild(table) |
| | mrow.appendChild(right) |
| | return mrow |
| |
|
| | def _get_printed_Rational(self, e, folded=None): |
| | if e.p < 0: |
| | p = -e.p |
| | else: |
| | p = e.p |
| | x = self.dom.createElement('mfrac') |
| | if folded or self._settings["fold_short_frac"]: |
| | x.setAttribute('bevelled', 'true') |
| | x.appendChild(self._print(p)) |
| | x.appendChild(self._print(e.q)) |
| | if e.p < 0: |
| | mrow = self.dom.createElement('mrow') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('-')) |
| | mrow.appendChild(mo) |
| | mrow.appendChild(x) |
| | return mrow |
| | else: |
| | return x |
| |
|
| | def _print_Rational(self, e): |
| | if e.q == 1: |
| | |
| | return self._print(e.p) |
| |
|
| | return self._get_printed_Rational(e, self._settings["fold_short_frac"]) |
| |
|
| | def _print_Limit(self, e): |
| | mrow = self.dom.createElement('mrow') |
| | munder = self.dom.createElement('munder') |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode('lim')) |
| |
|
| | x = self.dom.createElement('mrow') |
| | x_1 = self._print(e.args[1]) |
| | arrow = self.dom.createElement('mo') |
| | arrow.appendChild(self.dom.createTextNode(self.mathml_tag(e))) |
| | x_2 = self._print(e.args[2]) |
| | x.appendChild(x_1) |
| | x.appendChild(arrow) |
| | x.appendChild(x_2) |
| |
|
| | munder.appendChild(mi) |
| | munder.appendChild(x) |
| | mrow.appendChild(munder) |
| | mrow.appendChild(self._print(e.args[0])) |
| |
|
| | return mrow |
| |
|
| | def _print_ImaginaryUnit(self, e): |
| | x = self.dom.createElement('mi') |
| | x.appendChild(self.dom.createTextNode('ⅈ')) |
| | return x |
| |
|
| | def _print_GoldenRatio(self, e): |
| | x = self.dom.createElement('mi') |
| | x.appendChild(self.dom.createTextNode('Φ')) |
| | return x |
| |
|
| | def _print_Exp1(self, e): |
| | x = self.dom.createElement('mi') |
| | x.appendChild(self.dom.createTextNode('ⅇ')) |
| | return x |
| |
|
| | def _print_Pi(self, e): |
| | x = self.dom.createElement('mi') |
| | x.appendChild(self.dom.createTextNode('π')) |
| | return x |
| |
|
| | def _print_Infinity(self, e): |
| | x = self.dom.createElement('mi') |
| | x.appendChild(self.dom.createTextNode('∞')) |
| | return x |
| |
|
| | def _print_NegativeInfinity(self, e): |
| | mrow = self.dom.createElement('mrow') |
| | y = self.dom.createElement('mo') |
| | y.appendChild(self.dom.createTextNode('-')) |
| | x = self._print_Infinity(e) |
| | mrow.appendChild(y) |
| | mrow.appendChild(x) |
| | return mrow |
| |
|
| | def _print_HBar(self, e): |
| | x = self.dom.createElement('mi') |
| | x.appendChild(self.dom.createTextNode('ℏ')) |
| | return x |
| |
|
| | def _print_EulerGamma(self, e): |
| | x = self.dom.createElement('mi') |
| | x.appendChild(self.dom.createTextNode('γ')) |
| | return x |
| |
|
| | def _print_TribonacciConstant(self, e): |
| | x = self.dom.createElement('mi') |
| | x.appendChild(self.dom.createTextNode('TribonacciConstant')) |
| | return x |
| |
|
| | def _print_Dagger(self, e): |
| | msup = self.dom.createElement('msup') |
| | msup.appendChild(self._print(e.args[0])) |
| | msup.appendChild(self.dom.createTextNode('†')) |
| | return msup |
| |
|
| | def _print_Contains(self, e): |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(self._print(e.args[0])) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('∈')) |
| | mrow.appendChild(mo) |
| | mrow.appendChild(self._print(e.args[1])) |
| | return mrow |
| |
|
| | def _print_HilbertSpace(self, e): |
| | x = self.dom.createElement('mi') |
| | x.appendChild(self.dom.createTextNode('ℋ')) |
| | return x |
| |
|
| | def _print_ComplexSpace(self, e): |
| | msup = self.dom.createElement('msup') |
| | msup.appendChild(self.dom.createTextNode('𝒞')) |
| | msup.appendChild(self._print(e.args[0])) |
| | return msup |
| |
|
| | def _print_FockSpace(self, e): |
| | x = self.dom.createElement('mi') |
| | x.appendChild(self.dom.createTextNode('ℱ')) |
| | return x |
| |
|
| |
|
| | def _print_Integral(self, expr): |
| | intsymbols = {1: "∫", 2: "∬", 3: "∭"} |
| |
|
| | mrow = self.dom.createElement('mrow') |
| | if len(expr.limits) <= 3 and all(len(lim) == 1 for lim in expr.limits): |
| | |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode(intsymbols[len(expr.limits)])) |
| | mrow.appendChild(mo) |
| | else: |
| | |
| | for lim in reversed(expr.limits): |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode(intsymbols[1])) |
| | if len(lim) == 1: |
| | mrow.appendChild(mo) |
| | if len(lim) == 2: |
| | msup = self.dom.createElement('msup') |
| | msup.appendChild(mo) |
| | msup.appendChild(self._print(lim[1])) |
| | mrow.appendChild(msup) |
| | if len(lim) == 3: |
| | msubsup = self.dom.createElement('msubsup') |
| | msubsup.appendChild(mo) |
| | msubsup.appendChild(self._print(lim[1])) |
| | msubsup.appendChild(self._print(lim[2])) |
| | mrow.appendChild(msubsup) |
| | |
| | mrow.appendChild(self.parenthesize(expr.function, PRECEDENCE["Mul"], |
| | strict=True)) |
| | |
| | for lim in reversed(expr.limits): |
| | d = self.dom.createElement('mo') |
| | d.appendChild(self.dom.createTextNode('ⅆ')) |
| | mrow.appendChild(d) |
| | mrow.appendChild(self._print(lim[0])) |
| | return mrow |
| |
|
| | def _print_Sum(self, e): |
| | limits = list(e.limits) |
| | subsup = self.dom.createElement('munderover') |
| | low_elem = self._print(limits[0][1]) |
| | up_elem = self._print(limits[0][2]) |
| | summand = self.dom.createElement('mo') |
| | summand.appendChild(self.dom.createTextNode(self.mathml_tag(e))) |
| |
|
| | low = self.dom.createElement('mrow') |
| | var = self._print(limits[0][0]) |
| | equal = self.dom.createElement('mo') |
| | equal.appendChild(self.dom.createTextNode('=')) |
| | low.appendChild(var) |
| | low.appendChild(equal) |
| | low.appendChild(low_elem) |
| |
|
| | subsup.appendChild(summand) |
| | subsup.appendChild(low) |
| | subsup.appendChild(up_elem) |
| |
|
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(subsup) |
| | mrow.appendChild(self.parenthesize(e.function, precedence_traditional(e))) |
| | return mrow |
| |
|
| | def _print_Symbol(self, sym, style='plain'): |
| | def join(items): |
| | if len(items) > 1: |
| | mrow = self.dom.createElement('mrow') |
| | for i, item in enumerate(items): |
| | if i > 0: |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode(" ")) |
| | mrow.appendChild(mo) |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode(item)) |
| | mrow.appendChild(mi) |
| | return mrow |
| | else: |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode(items[0])) |
| | return mi |
| |
|
| | |
| | def translate(s): |
| | if s in greek_unicode: |
| | return greek_unicode.get(s) |
| | else: |
| | return s |
| |
|
| | name, supers, subs = self._split_super_sub(sym.name) |
| | name = translate(name) |
| | supers = [translate(sup) for sup in supers] |
| | subs = [translate(sub) for sub in subs] |
| |
|
| | mname = self.dom.createElement('mi') |
| | mname.appendChild(self.dom.createTextNode(name)) |
| | if len(supers) == 0: |
| | if len(subs) == 0: |
| | x = mname |
| | else: |
| | x = self.dom.createElement('msub') |
| | x.appendChild(mname) |
| | x.appendChild(join(subs)) |
| | else: |
| | if len(subs) == 0: |
| | x = self.dom.createElement('msup') |
| | x.appendChild(mname) |
| | x.appendChild(join(supers)) |
| | else: |
| | x = self.dom.createElement('msubsup') |
| | x.appendChild(mname) |
| | x.appendChild(join(subs)) |
| | x.appendChild(join(supers)) |
| | |
| | if style == 'bold': |
| | x.setAttribute('mathvariant', 'bold') |
| | return x |
| |
|
| | def _print_MatrixSymbol(self, sym): |
| | return self._print_Symbol(sym, |
| | style=self._settings['mat_symbol_style']) |
| |
|
| | _print_RandomSymbol = _print_Symbol |
| |
|
| | def _print_conjugate(self, expr): |
| | enc = self.dom.createElement('menclose') |
| | enc.setAttribute('notation', 'top') |
| | enc.appendChild(self._print(expr.args[0])) |
| | return enc |
| |
|
| | def _print_operator_after(self, op, expr): |
| | row = self.dom.createElement('mrow') |
| | row.appendChild(self.parenthesize(expr, PRECEDENCE["Func"])) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode(op)) |
| | row.appendChild(mo) |
| | return row |
| |
|
| | def _print_factorial(self, expr): |
| | return self._print_operator_after('!', expr.args[0]) |
| |
|
| | def _print_factorial2(self, expr): |
| | return self._print_operator_after('!!', expr.args[0]) |
| |
|
| | def _print_binomial(self, expr): |
| | frac = self.dom.createElement('mfrac') |
| | frac.setAttribute('linethickness', '0') |
| | frac.appendChild(self._print(expr.args[0])) |
| | frac.appendChild(self._print(expr.args[1])) |
| | brac = self.dom.createElement('mrow') |
| | brac.appendChild(self._l_paren()) |
| | brac.appendChild(frac) |
| | brac.appendChild(self._r_paren()) |
| | return brac |
| |
|
| | def _print_Pow(self, e): |
| | |
| | |
| | if (e.exp.is_Rational and abs(e.exp.p) == 1 and e.exp.q != 1 and |
| | self._settings['root_notation']): |
| | if e.exp.q == 2: |
| | x = self.dom.createElement('msqrt') |
| | x.appendChild(self._print(e.base)) |
| | if e.exp.q != 2: |
| | x = self.dom.createElement('mroot') |
| | x.appendChild(self._print(e.base)) |
| | x.appendChild(self._print(e.exp.q)) |
| | if e.exp.p == -1: |
| | frac = self.dom.createElement('mfrac') |
| | frac.appendChild(self._print(1)) |
| | frac.appendChild(x) |
| | return frac |
| | else: |
| | return x |
| |
|
| | if e.exp.is_Rational and e.exp.q != 1: |
| | if e.exp.is_negative: |
| | top = self.dom.createElement('mfrac') |
| | top.appendChild(self._print(1)) |
| | x = self.dom.createElement('msup') |
| | x.appendChild(self.parenthesize(e.base, PRECEDENCE['Pow'])) |
| | x.appendChild(self._get_printed_Rational(-e.exp, |
| | self._settings['fold_frac_powers'])) |
| | top.appendChild(x) |
| | return top |
| | else: |
| | x = self.dom.createElement('msup') |
| | x.appendChild(self.parenthesize(e.base, PRECEDENCE['Pow'])) |
| | x.appendChild(self._get_printed_Rational(e.exp, |
| | self._settings['fold_frac_powers'])) |
| | return x |
| |
|
| | if e.exp.is_negative: |
| | top = self.dom.createElement('mfrac') |
| | top.appendChild(self._print(1)) |
| | if e.exp == -1: |
| | top.appendChild(self._print(e.base)) |
| | else: |
| | x = self.dom.createElement('msup') |
| | x.appendChild(self.parenthesize(e.base, PRECEDENCE['Pow'])) |
| | x.appendChild(self._print(-e.exp)) |
| | top.appendChild(x) |
| | return top |
| |
|
| | x = self.dom.createElement('msup') |
| | x.appendChild(self.parenthesize(e.base, PRECEDENCE['Pow'])) |
| | x.appendChild(self._print(e.exp)) |
| | return x |
| |
|
| | def _print_Number(self, e): |
| | x = self.dom.createElement(self.mathml_tag(e)) |
| | x.appendChild(self.dom.createTextNode(str(e))) |
| | return x |
| |
|
| | def _print_AccumulationBounds(self, i): |
| | left = self.dom.createElement('mo') |
| | left.appendChild(self.dom.createTextNode('\u27e8')) |
| | right = self.dom.createElement('mo') |
| | right.appendChild(self.dom.createTextNode('\u27e9')) |
| | brac = self.dom.createElement('mrow') |
| | brac.appendChild(left) |
| | brac.appendChild(self._print(i.min)) |
| | brac.appendChild(self._comma()) |
| | brac.appendChild(self._print(i.max)) |
| | brac.appendChild(right) |
| | return brac |
| |
|
| | def _print_Derivative(self, e): |
| |
|
| | if requires_partial(e.expr): |
| | d = '∂' |
| | else: |
| | d = self.mathml_tag(e) |
| |
|
| | |
| | m = self.dom.createElement('mrow') |
| | dim = 0 |
| | for sym, num in reversed(e.variable_count): |
| | dim += num |
| | if num >= 2: |
| | x = self.dom.createElement('msup') |
| | xx = self.dom.createElement('mo') |
| | xx.appendChild(self.dom.createTextNode(d)) |
| | x.appendChild(xx) |
| | x.appendChild(self._print(num)) |
| | else: |
| | x = self.dom.createElement('mo') |
| | x.appendChild(self.dom.createTextNode(d)) |
| | m.appendChild(x) |
| | y = self._print(sym) |
| | m.appendChild(y) |
| |
|
| | mnum = self.dom.createElement('mrow') |
| | if dim >= 2: |
| | x = self.dom.createElement('msup') |
| | xx = self.dom.createElement('mo') |
| | xx.appendChild(self.dom.createTextNode(d)) |
| | x.appendChild(xx) |
| | x.appendChild(self._print(dim)) |
| | else: |
| | x = self.dom.createElement('mo') |
| | x.appendChild(self.dom.createTextNode(d)) |
| |
|
| | mnum.appendChild(x) |
| | mrow = self.dom.createElement('mrow') |
| | frac = self.dom.createElement('mfrac') |
| | frac.appendChild(mnum) |
| | frac.appendChild(m) |
| | mrow.appendChild(frac) |
| |
|
| | |
| | mrow.appendChild(self._print(e.expr)) |
| |
|
| | return mrow |
| |
|
| | def _print_Function(self, e): |
| | x = self.dom.createElement('mi') |
| | if self.mathml_tag(e) == 'log' and self._settings["ln_notation"]: |
| | x.appendChild(self.dom.createTextNode('ln')) |
| | else: |
| | x.appendChild(self.dom.createTextNode(self.mathml_tag(e))) |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(x) |
| | mrow.appendChild(self._paren_comma_separated(*e.args)) |
| | return mrow |
| |
|
| | def _print_Float(self, expr): |
| | |
| | dps = prec_to_dps(expr._prec) |
| | str_real = mlib_to_str(expr._mpf_, dps, strip_zeros=True) |
| |
|
| | |
| | |
| | separator = self._settings['mul_symbol_mathml_numbers'] |
| | mrow = self.dom.createElement('mrow') |
| | if 'e' in str_real: |
| | (mant, exp) = str_real.split('e') |
| |
|
| | if exp[0] == '+': |
| | exp = exp[1:] |
| |
|
| | mn = self.dom.createElement('mn') |
| | mn.appendChild(self.dom.createTextNode(mant)) |
| | mrow.appendChild(mn) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode(separator)) |
| | mrow.appendChild(mo) |
| | msup = self.dom.createElement('msup') |
| | mn = self.dom.createElement('mn') |
| | mn.appendChild(self.dom.createTextNode("10")) |
| | msup.appendChild(mn) |
| | mn = self.dom.createElement('mn') |
| | mn.appendChild(self.dom.createTextNode(exp)) |
| | msup.appendChild(mn) |
| | mrow.appendChild(msup) |
| | return mrow |
| | elif str_real == "+inf": |
| | return self._print_Infinity(None) |
| | elif str_real == "-inf": |
| | return self._print_NegativeInfinity(None) |
| | else: |
| | mn = self.dom.createElement('mn') |
| | mn.appendChild(self.dom.createTextNode(str_real)) |
| | return mn |
| |
|
| | def _print_polylog(self, expr): |
| | mrow = self.dom.createElement('mrow') |
| | m = self.dom.createElement('msub') |
| |
|
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode('Li')) |
| | m.appendChild(mi) |
| | m.appendChild(self._print(expr.args[0])) |
| | mrow.appendChild(m) |
| | brac = self.dom.createElement('mrow') |
| | brac.appendChild(self._l_paren()) |
| | brac.appendChild(self._print(expr.args[1])) |
| | brac.appendChild(self._r_paren()) |
| | mrow.appendChild(brac) |
| | return mrow |
| |
|
| | def _print_Basic(self, e): |
| | mrow = self.dom.createElement('mrow') |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode(self.mathml_tag(e))) |
| | mrow.appendChild(mi) |
| | mrow.appendChild(self._paren_comma_separated(*e.args)) |
| | return mrow |
| |
|
| | def _print_Tuple(self, e): |
| | return self._paren_comma_separated(*e.args) |
| |
|
| | def _print_Interval(self, i): |
| | right = self.dom.createElement('mo') |
| | if i.right_open: |
| | right.appendChild(self.dom.createTextNode(')')) |
| | else: |
| | right.appendChild(self.dom.createTextNode(']')) |
| | left = self.dom.createElement('mo') |
| | if i.left_open: |
| | left.appendChild(self.dom.createTextNode('(')) |
| | else: |
| | left.appendChild(self.dom.createTextNode('[')) |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(left) |
| | mrow.appendChild(self._print(i.start)) |
| | mrow.appendChild(self._comma()) |
| | mrow.appendChild(self._print(i.end)) |
| | mrow.appendChild(right) |
| | return mrow |
| |
|
| | def _print_Abs(self, expr, exp=None): |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(self._bar()) |
| | mrow.appendChild(self._print(expr.args[0])) |
| | mrow.appendChild(self._bar()) |
| | return mrow |
| |
|
| | _print_Determinant = _print_Abs |
| |
|
| | def _print_re_im(self, c, expr): |
| | brac = self.dom.createElement('mrow') |
| | brac.appendChild(self._l_paren()) |
| | brac.appendChild(self._print(expr)) |
| | brac.appendChild(self._r_paren()) |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode(c)) |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(mi) |
| | mrow.appendChild(brac) |
| | return mrow |
| |
|
| | def _print_re(self, expr, exp=None): |
| | return self._print_re_im('\u211C', expr.args[0]) |
| |
|
| | def _print_im(self, expr, exp=None): |
| | return self._print_re_im('\u2111', expr.args[0]) |
| |
|
| | def _print_AssocOp(self, e): |
| | mrow = self.dom.createElement('mrow') |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode(self.mathml_tag(e))) |
| | mrow.appendChild(mi) |
| | for arg in e.args: |
| | mrow.appendChild(self._print(arg)) |
| | return mrow |
| |
|
| | def _print_SetOp(self, expr, symbol, prec): |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(self.parenthesize(expr.args[0], prec)) |
| | for arg in expr.args[1:]: |
| | x = self.dom.createElement('mo') |
| | x.appendChild(self.dom.createTextNode(symbol)) |
| | y = self.parenthesize(arg, prec) |
| | mrow.appendChild(x) |
| | mrow.appendChild(y) |
| | return mrow |
| |
|
| | def _print_Union(self, expr): |
| | prec = PRECEDENCE_TRADITIONAL['Union'] |
| | return self._print_SetOp(expr, '∪', prec) |
| |
|
| | def _print_Intersection(self, expr): |
| | prec = PRECEDENCE_TRADITIONAL['Intersection'] |
| | return self._print_SetOp(expr, '∩', prec) |
| |
|
| | def _print_Complement(self, expr): |
| | prec = PRECEDENCE_TRADITIONAL['Complement'] |
| | return self._print_SetOp(expr, '∖', prec) |
| |
|
| | def _print_SymmetricDifference(self, expr): |
| | prec = PRECEDENCE_TRADITIONAL['SymmetricDifference'] |
| | return self._print_SetOp(expr, '∆', prec) |
| |
|
| | def _print_ProductSet(self, expr): |
| | prec = PRECEDENCE_TRADITIONAL['ProductSet'] |
| | return self._print_SetOp(expr, '×', prec) |
| |
|
| | def _print_FiniteSet(self, s): |
| | return self._print_set(s.args) |
| |
|
| | def _print_set(self, s): |
| | items = sorted(s, key=default_sort_key) |
| | brac = self.dom.createElement('mrow') |
| | brac.appendChild(self._l_brace()) |
| | for i, item in enumerate(items): |
| | if i: |
| | brac.appendChild(self._comma()) |
| | brac.appendChild(self._print(item)) |
| | brac.appendChild(self._r_brace()) |
| | return brac |
| |
|
| | _print_frozenset = _print_set |
| |
|
| | def _print_LogOp(self, args, symbol): |
| | mrow = self.dom.createElement('mrow') |
| | if args[0].is_Boolean and not args[0].is_Not: |
| | brac = self.dom.createElement('mrow') |
| | brac.appendChild(self._l_paren()) |
| | brac.appendChild(self._print(args[0])) |
| | brac.appendChild(self._r_paren()) |
| | mrow.appendChild(brac) |
| | else: |
| | mrow.appendChild(self._print(args[0])) |
| | for arg in args[1:]: |
| | x = self.dom.createElement('mo') |
| | x.appendChild(self.dom.createTextNode(symbol)) |
| | if arg.is_Boolean and not arg.is_Not: |
| | y = self.dom.createElement('mrow') |
| | y.appendChild(self._l_paren()) |
| | y.appendChild(self._print(arg)) |
| | y.appendChild(self._r_paren()) |
| | else: |
| | y = self._print(arg) |
| | mrow.appendChild(x) |
| | mrow.appendChild(y) |
| | return mrow |
| |
|
| | def _print_BasisDependent(self, expr): |
| | from sympy.vector import Vector |
| |
|
| | if expr == expr.zero: |
| | |
| | return self._print(expr.zero) |
| | if isinstance(expr, Vector): |
| | items = expr.separate().items() |
| | else: |
| | items = [(0, expr)] |
| |
|
| | mrow = self.dom.createElement('mrow') |
| | for system, vect in items: |
| | inneritems = list(vect.components.items()) |
| | inneritems.sort(key = lambda x:x[0].__str__()) |
| | for i, (k, v) in enumerate(inneritems): |
| | if v == 1: |
| | if i: |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('+')) |
| | mrow.appendChild(mo) |
| | mrow.appendChild(self._print(k)) |
| | elif v == -1: |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('-')) |
| | mrow.appendChild(mo) |
| | mrow.appendChild(self._print(k)) |
| | else: |
| | if i: |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('+')) |
| | mrow.appendChild(mo) |
| | mbrac = self.dom.createElement('mrow') |
| | mbrac.appendChild(self._l_paren()) |
| | mbrac.appendChild(self._print(v)) |
| | mbrac.appendChild(self._r_paren()) |
| | mrow.appendChild(mbrac) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('⁢')) |
| | mrow.appendChild(mo) |
| | mrow.appendChild(self._print(k)) |
| | return mrow |
| |
|
| |
|
| | def _print_And(self, expr): |
| | args = sorted(expr.args, key=default_sort_key) |
| | return self._print_LogOp(args, '∧') |
| |
|
| | def _print_Or(self, expr): |
| | args = sorted(expr.args, key=default_sort_key) |
| | return self._print_LogOp(args, '∨') |
| |
|
| | def _print_Xor(self, expr): |
| | args = sorted(expr.args, key=default_sort_key) |
| | return self._print_LogOp(args, '⊻') |
| |
|
| | def _print_Implies(self, expr): |
| | return self._print_LogOp(expr.args, '⇒') |
| |
|
| | def _print_Equivalent(self, expr): |
| | args = sorted(expr.args, key=default_sort_key) |
| | return self._print_LogOp(args, '⇔') |
| |
|
| | def _print_Not(self, e): |
| | mrow = self.dom.createElement('mrow') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('¬')) |
| | mrow.appendChild(mo) |
| | if (e.args[0].is_Boolean): |
| | x = self.dom.createElement('mrow') |
| | x.appendChild(self._l_paren()) |
| | x.appendChild(self._print(e.args[0])) |
| | x.appendChild(self._r_paren()) |
| | else: |
| | x = self._print(e.args[0]) |
| | mrow.appendChild(x) |
| | return mrow |
| |
|
| | def _print_bool(self, e): |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode(self.mathml_tag(e))) |
| | return mi |
| |
|
| | _print_BooleanTrue = _print_bool |
| | _print_BooleanFalse = _print_bool |
| |
|
| | def _print_NoneType(self, e): |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode(self.mathml_tag(e))) |
| | return mi |
| |
|
| | def _print_Range(self, s): |
| | dots = "\u2026" |
| | if s.start.is_infinite and s.stop.is_infinite: |
| | if s.step.is_positive: |
| | printset = dots, -1, 0, 1, dots |
| | else: |
| | printset = dots, 1, 0, -1, dots |
| | elif s.start.is_infinite: |
| | printset = dots, s[-1] - s.step, s[-1] |
| | elif s.stop.is_infinite: |
| | it = iter(s) |
| | printset = next(it), next(it), dots |
| | elif len(s) > 4: |
| | it = iter(s) |
| | printset = next(it), next(it), dots, s[-1] |
| | else: |
| | printset = tuple(s) |
| | brac = self.dom.createElement('mrow') |
| | brac.appendChild(self._l_brace()) |
| | for i, el in enumerate(printset): |
| | if i: |
| | brac.appendChild(self._comma()) |
| | if el == dots: |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode(dots)) |
| | brac.appendChild(mi) |
| | else: |
| | brac.appendChild(self._print(el)) |
| | brac.appendChild(self._r_brace()) |
| | return brac |
| |
|
| | def _hprint_variadic_function(self, expr): |
| | args = sorted(expr.args, key=default_sort_key) |
| | mrow = self.dom.createElement('mrow') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode((str(expr.func)).lower())) |
| | mrow.appendChild(mo) |
| | mrow.appendChild(self._paren_comma_separated(*args)) |
| | return mrow |
| |
|
| | _print_Min = _print_Max = _hprint_variadic_function |
| |
|
| | def _print_exp(self, expr): |
| | msup = self.dom.createElement('msup') |
| | msup.appendChild(self._print_Exp1(None)) |
| | msup.appendChild(self._print(expr.args[0])) |
| | return msup |
| |
|
| | def _print_Relational(self, e): |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(self._print(e.lhs)) |
| | x = self.dom.createElement('mo') |
| | x.appendChild(self.dom.createTextNode(self.mathml_tag(e))) |
| | mrow.appendChild(x) |
| | mrow.appendChild(self._print(e.rhs)) |
| | return mrow |
| |
|
| | def _print_int(self, p): |
| | dom_element = self.dom.createElement(self.mathml_tag(p)) |
| | dom_element.appendChild(self.dom.createTextNode(str(p))) |
| | return dom_element |
| |
|
| | def _print_BaseScalar(self, e): |
| | msub = self.dom.createElement('msub') |
| | index, system = e._id |
| | mi = self.dom.createElement('mi') |
| | mi.setAttribute('mathvariant', 'bold') |
| | mi.appendChild(self.dom.createTextNode(system._variable_names[index])) |
| | msub.appendChild(mi) |
| | mi = self.dom.createElement('mi') |
| | mi.setAttribute('mathvariant', 'bold') |
| | mi.appendChild(self.dom.createTextNode(system._name)) |
| | msub.appendChild(mi) |
| | return msub |
| |
|
| | def _print_BaseVector(self, e): |
| | msub = self.dom.createElement('msub') |
| | index, system = e._id |
| | mover = self.dom.createElement('mover') |
| | mi = self.dom.createElement('mi') |
| | mi.setAttribute('mathvariant', 'bold') |
| | mi.appendChild(self.dom.createTextNode(system._vector_names[index])) |
| | mover.appendChild(mi) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('^')) |
| | mover.appendChild(mo) |
| | msub.appendChild(mover) |
| | mi = self.dom.createElement('mi') |
| | mi.setAttribute('mathvariant', 'bold') |
| | mi.appendChild(self.dom.createTextNode(system._name)) |
| | msub.appendChild(mi) |
| | return msub |
| |
|
| | def _print_VectorZero(self, e): |
| | mover = self.dom.createElement('mover') |
| | mi = self.dom.createElement('mi') |
| | mi.setAttribute('mathvariant', 'bold') |
| | mi.appendChild(self.dom.createTextNode("0")) |
| | mover.appendChild(mi) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('^')) |
| | mover.appendChild(mo) |
| | return mover |
| |
|
| | def _print_Cross(self, expr): |
| | mrow = self.dom.createElement('mrow') |
| | vec1 = expr._expr1 |
| | vec2 = expr._expr2 |
| | mrow.appendChild(self.parenthesize(vec1, PRECEDENCE['Mul'])) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('×')) |
| | mrow.appendChild(mo) |
| | mrow.appendChild(self.parenthesize(vec2, PRECEDENCE['Mul'])) |
| | return mrow |
| |
|
| | def _print_Curl(self, expr): |
| | mrow = self.dom.createElement('mrow') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('∇')) |
| | mrow.appendChild(mo) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('×')) |
| | mrow.appendChild(mo) |
| | mrow.appendChild(self.parenthesize(expr._expr, PRECEDENCE['Mul'])) |
| | return mrow |
| |
|
| | def _print_Divergence(self, expr): |
| | mrow = self.dom.createElement('mrow') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('∇')) |
| | mrow.appendChild(mo) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('·')) |
| | mrow.appendChild(mo) |
| | mrow.appendChild(self.parenthesize(expr._expr, PRECEDENCE['Mul'])) |
| | return mrow |
| |
|
| | def _print_Dot(self, expr): |
| | mrow = self.dom.createElement('mrow') |
| | vec1 = expr._expr1 |
| | vec2 = expr._expr2 |
| | mrow.appendChild(self.parenthesize(vec1, PRECEDENCE['Mul'])) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('·')) |
| | mrow.appendChild(mo) |
| | mrow.appendChild(self.parenthesize(vec2, PRECEDENCE['Mul'])) |
| | return mrow |
| |
|
| | def _print_Gradient(self, expr): |
| | mrow = self.dom.createElement('mrow') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('∇')) |
| | mrow.appendChild(mo) |
| | mrow.appendChild(self.parenthesize(expr._expr, PRECEDENCE['Mul'])) |
| | return mrow |
| |
|
| | def _print_Laplacian(self, expr): |
| | mrow = self.dom.createElement('mrow') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('∆')) |
| | mrow.appendChild(mo) |
| | mrow.appendChild(self.parenthesize(expr._expr, PRECEDENCE['Mul'])) |
| | return mrow |
| |
|
| | def _print_Integers(self, e): |
| | x = self.dom.createElement('mi') |
| | x.setAttribute('mathvariant', 'normal') |
| | x.appendChild(self.dom.createTextNode('ℤ')) |
| | return x |
| |
|
| | def _print_Complexes(self, e): |
| | x = self.dom.createElement('mi') |
| | x.setAttribute('mathvariant', 'normal') |
| | x.appendChild(self.dom.createTextNode('ℂ')) |
| | return x |
| |
|
| | def _print_Reals(self, e): |
| | x = self.dom.createElement('mi') |
| | x.setAttribute('mathvariant', 'normal') |
| | x.appendChild(self.dom.createTextNode('ℝ')) |
| | return x |
| |
|
| | def _print_Naturals(self, e): |
| | x = self.dom.createElement('mi') |
| | x.setAttribute('mathvariant', 'normal') |
| | x.appendChild(self.dom.createTextNode('ℕ')) |
| | return x |
| |
|
| | def _print_Naturals0(self, e): |
| | sub = self.dom.createElement('msub') |
| | x = self.dom.createElement('mi') |
| | x.setAttribute('mathvariant', 'normal') |
| | x.appendChild(self.dom.createTextNode('ℕ')) |
| | sub.appendChild(x) |
| | sub.appendChild(self._print(S.Zero)) |
| | return sub |
| |
|
| | def _print_SingularityFunction(self, expr): |
| | shift = expr.args[0] - expr.args[1] |
| | power = expr.args[2] |
| | left = self.dom.createElement('mo') |
| | left.appendChild(self.dom.createTextNode('\u27e8')) |
| | right = self.dom.createElement('mo') |
| | right.appendChild(self.dom.createTextNode('\u27e9')) |
| | brac = self.dom.createElement('mrow') |
| | brac.appendChild(left) |
| | brac.appendChild(self._print(shift)) |
| | brac.appendChild(right) |
| | sup = self.dom.createElement('msup') |
| | sup.appendChild(brac) |
| | sup.appendChild(self._print(power)) |
| | return sup |
| |
|
| | def _print_NaN(self, e): |
| | x = self.dom.createElement('mi') |
| | x.appendChild(self.dom.createTextNode('NaN')) |
| | return x |
| |
|
| | def _print_number_function(self, e, name): |
| | |
| | |
| | sub = self.dom.createElement('msub') |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode(name)) |
| | sub.appendChild(mi) |
| | sub.appendChild(self._print(e.args[0])) |
| | if len(e.args) == 1: |
| | return sub |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(sub) |
| | mrow.appendChild(self._paren_comma_separated(*e.args[1:])) |
| | return mrow |
| |
|
| | def _print_bernoulli(self, e): |
| | return self._print_number_function(e, 'B') |
| |
|
| | _print_bell = _print_bernoulli |
| |
|
| | def _print_catalan(self, e): |
| | return self._print_number_function(e, 'C') |
| |
|
| | def _print_euler(self, e): |
| | return self._print_number_function(e, 'E') |
| |
|
| | def _print_fibonacci(self, e): |
| | return self._print_number_function(e, 'F') |
| |
|
| | def _print_lucas(self, e): |
| | return self._print_number_function(e, 'L') |
| |
|
| | def _print_stieltjes(self, e): |
| | return self._print_number_function(e, 'γ') |
| |
|
| | def _print_tribonacci(self, e): |
| | return self._print_number_function(e, 'T') |
| |
|
| | def _print_ComplexInfinity(self, e): |
| | x = self.dom.createElement('mover') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('∞')) |
| | x.appendChild(mo) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('~')) |
| | x.appendChild(mo) |
| | return x |
| |
|
| | def _print_EmptySet(self, e): |
| | x = self.dom.createElement('mo') |
| | x.appendChild(self.dom.createTextNode('∅')) |
| | return x |
| |
|
| | def _print_UniversalSet(self, e): |
| | x = self.dom.createElement('mo') |
| | x.appendChild(self.dom.createTextNode('𝕌')) |
| | return x |
| |
|
| | def _print_Adjoint(self, expr): |
| | from sympy.matrices import MatrixSymbol |
| | mat = expr.arg |
| | sup = self.dom.createElement('msup') |
| | if not isinstance(mat, MatrixSymbol): |
| | brac = self.dom.createElement('mrow') |
| | brac.appendChild(self._l_paren()) |
| | brac.appendChild(self._print(mat)) |
| | brac.appendChild(self._r_paren()) |
| | sup.appendChild(brac) |
| | else: |
| | sup.appendChild(self._print(mat)) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('†')) |
| | sup.appendChild(mo) |
| | return sup |
| |
|
| | def _print_Transpose(self, expr): |
| | from sympy.matrices import MatrixSymbol |
| | mat = expr.arg |
| | sup = self.dom.createElement('msup') |
| | if not isinstance(mat, MatrixSymbol): |
| | brac = self.dom.createElement('mrow') |
| | brac.appendChild(self._l_paren()) |
| | brac.appendChild(self._print(mat)) |
| | brac.appendChild(self._r_paren()) |
| | sup.appendChild(brac) |
| | else: |
| | sup.appendChild(self._print(mat)) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('T')) |
| | sup.appendChild(mo) |
| | return sup |
| |
|
| | def _print_Inverse(self, expr): |
| | from sympy.matrices import MatrixSymbol |
| | mat = expr.arg |
| | sup = self.dom.createElement('msup') |
| | if not isinstance(mat, MatrixSymbol): |
| | brac = self.dom.createElement('mrow') |
| | brac.appendChild(self._l_paren()) |
| | brac.appendChild(self._print(mat)) |
| | brac.appendChild(self._r_paren()) |
| | sup.appendChild(brac) |
| | else: |
| | sup.appendChild(self._print(mat)) |
| | sup.appendChild(self._print(-1)) |
| | return sup |
| |
|
| | def _print_MatMul(self, expr): |
| | from sympy.matrices.expressions.matmul import MatMul |
| |
|
| | x = self.dom.createElement('mrow') |
| | args = expr.args |
| | if isinstance(args[0], Mul): |
| | args = args[0].as_ordered_factors() + list(args[1:]) |
| | else: |
| | args = list(args) |
| |
|
| | if isinstance(expr, MatMul) and expr.could_extract_minus_sign(): |
| | if args[0] == -1: |
| | args = args[1:] |
| | else: |
| | args[0] = -args[0] |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('-')) |
| | x.appendChild(mo) |
| |
|
| | for arg in args[:-1]: |
| | x.appendChild(self.parenthesize(arg, precedence_traditional(expr), |
| | False)) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('⁢')) |
| | x.appendChild(mo) |
| | x.appendChild(self.parenthesize(args[-1], precedence_traditional(expr), |
| | False)) |
| | return x |
| |
|
| | def _print_MatPow(self, expr): |
| | from sympy.matrices import MatrixSymbol |
| | base, exp = expr.base, expr.exp |
| | sup = self.dom.createElement('msup') |
| | if not isinstance(base, MatrixSymbol): |
| | brac = self.dom.createElement('mrow') |
| | brac.appendChild(self._l_paren()) |
| | brac.appendChild(self._print(base)) |
| | brac.appendChild(self._r_paren()) |
| | sup.appendChild(brac) |
| | else: |
| | sup.appendChild(self._print(base)) |
| | sup.appendChild(self._print(exp)) |
| | return sup |
| |
|
| | def _print_HadamardProduct(self, expr): |
| | x = self.dom.createElement('mrow') |
| | args = expr.args |
| | for arg in args[:-1]: |
| | x.appendChild( |
| | self.parenthesize(arg, precedence_traditional(expr), False)) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('∘')) |
| | x.appendChild(mo) |
| | x.appendChild( |
| | self.parenthesize(args[-1], precedence_traditional(expr), False)) |
| | return x |
| |
|
| | def _print_ZeroMatrix(self, Z): |
| | x = self.dom.createElement('mn') |
| | x.appendChild(self.dom.createTextNode('𝟘')) |
| | return x |
| |
|
| | def _print_OneMatrix(self, Z): |
| | x = self.dom.createElement('mn') |
| | x.appendChild(self.dom.createTextNode('𝟙')) |
| | return x |
| |
|
| | def _print_Identity(self, I): |
| | x = self.dom.createElement('mi') |
| | x.appendChild(self.dom.createTextNode('𝕀')) |
| | return x |
| |
|
| | def _print_floor(self, e): |
| | left = self.dom.createElement('mo') |
| | left.appendChild(self.dom.createTextNode('\u230A')) |
| | right = self.dom.createElement('mo') |
| | right.appendChild(self.dom.createTextNode('\u230B')) |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(left) |
| | mrow.appendChild(self._print(e.args[0])) |
| | mrow.appendChild(right) |
| | return mrow |
| |
|
| | def _print_ceiling(self, e): |
| | left = self.dom.createElement('mo') |
| | left.appendChild(self.dom.createTextNode('\u2308')) |
| | right = self.dom.createElement('mo') |
| | right.appendChild(self.dom.createTextNode('\u2309')) |
| | mrow = self.dom.createElement('mrow') |
| | mrow.appendChild(left) |
| | mrow.appendChild(self._print(e.args[0])) |
| | mrow.appendChild(right) |
| | return mrow |
| |
|
| | def _print_Lambda(self, e): |
| | mrow = self.dom.createElement('mrow') |
| | symbols = e.args[0] |
| | if len(symbols) == 1: |
| | symbols = self._print(symbols[0]) |
| | else: |
| | symbols = self._print(symbols) |
| | mrow.appendChild(self._l_paren()) |
| | mrow.appendChild(symbols) |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('↦')) |
| | mrow.appendChild(mo) |
| | mrow.appendChild(self._print(e.args[1])) |
| | mrow.appendChild(self._r_paren()) |
| | return mrow |
| |
|
| | def _print_tuple(self, e): |
| | return self._paren_comma_separated(*e) |
| |
|
| | def _print_IndexedBase(self, e): |
| | return self._print(e.label) |
| |
|
| | def _print_Indexed(self, e): |
| | x = self.dom.createElement('msub') |
| | x.appendChild(self._print(e.base)) |
| | if len(e.indices) == 1: |
| | x.appendChild(self._print(e.indices[0])) |
| | return x |
| | x.appendChild(self._print(e.indices)) |
| | return x |
| |
|
| | def _print_MatrixElement(self, e): |
| | x = self.dom.createElement('msub') |
| | x.appendChild(self.parenthesize(e.parent, PRECEDENCE["Atom"], strict = True)) |
| | brac = self.dom.createElement('mrow') |
| | for i, arg in enumerate(e.indices): |
| | if i: |
| | brac.appendChild(self._comma()) |
| | brac.appendChild(self._print(arg)) |
| | x.appendChild(brac) |
| | return x |
| |
|
| | def _print_elliptic_f(self, e): |
| | x = self.dom.createElement('mrow') |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode('𝖥')) |
| | x.appendChild(mi) |
| | x.appendChild(self._paren_bar_separated(*e.args)) |
| | return x |
| |
|
| | def _print_elliptic_e(self, e): |
| | x = self.dom.createElement('mrow') |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode('𝖤')) |
| | x.appendChild(mi) |
| | x.appendChild(self._paren_bar_separated(*e.args)) |
| | return x |
| |
|
| | def _print_elliptic_pi(self, e): |
| | x = self.dom.createElement('mrow') |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode('𝛱')) |
| | x.appendChild(mi) |
| | y = self.dom.createElement('mrow') |
| | y.appendChild(self._l_paren()) |
| | if len(e.args) == 2: |
| | n, m = e.args |
| | y.appendChild(self._print(n)) |
| | y.appendChild(self._bar()) |
| | y.appendChild(self._print(m)) |
| | else: |
| | n, m, z = e.args |
| | y.appendChild(self._print(n)) |
| | y.appendChild(self._semicolon()) |
| | y.appendChild(self._print(m)) |
| | y.appendChild(self._bar()) |
| | y.appendChild(self._print(z)) |
| | y.appendChild(self._r_paren()) |
| | x.appendChild(y) |
| | return x |
| |
|
| | def _print_Ei(self, e): |
| | x = self.dom.createElement('mrow') |
| | mi = self.dom.createElement('mi') |
| | mi.appendChild(self.dom.createTextNode('Ei')) |
| | x.appendChild(mi) |
| | x.appendChild(self._print(e.args)) |
| | return x |
| |
|
| | def _print_expint(self, e): |
| | x = self.dom.createElement('mrow') |
| | y = self.dom.createElement('msub') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('E')) |
| | y.appendChild(mo) |
| | y.appendChild(self._print(e.args[0])) |
| | x.appendChild(y) |
| | x.appendChild(self._print(e.args[1:])) |
| | return x |
| |
|
| | def _print_jacobi(self, e): |
| | x = self.dom.createElement('mrow') |
| | y = self.dom.createElement('msubsup') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('P')) |
| | y.appendChild(mo) |
| | y.appendChild(self._print(e.args[0])) |
| | y.appendChild(self._print(e.args[1:3])) |
| | x.appendChild(y) |
| | x.appendChild(self._print(e.args[3:])) |
| | return x |
| |
|
| | def _print_gegenbauer(self, e): |
| | x = self.dom.createElement('mrow') |
| | y = self.dom.createElement('msubsup') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('C')) |
| | y.appendChild(mo) |
| | y.appendChild(self._print(e.args[0])) |
| | y.appendChild(self._print(e.args[1:2])) |
| | x.appendChild(y) |
| | x.appendChild(self._print(e.args[2:])) |
| | return x |
| |
|
| | def _print_chebyshevt(self, e): |
| | x = self.dom.createElement('mrow') |
| | y = self.dom.createElement('msub') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('T')) |
| | y.appendChild(mo) |
| | y.appendChild(self._print(e.args[0])) |
| | x.appendChild(y) |
| | x.appendChild(self._print(e.args[1:])) |
| | return x |
| |
|
| | def _print_chebyshevu(self, e): |
| | x = self.dom.createElement('mrow') |
| | y = self.dom.createElement('msub') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('U')) |
| | y.appendChild(mo) |
| | y.appendChild(self._print(e.args[0])) |
| | x.appendChild(y) |
| | x.appendChild(self._print(e.args[1:])) |
| | return x |
| |
|
| | def _print_legendre(self, e): |
| | x = self.dom.createElement('mrow') |
| | y = self.dom.createElement('msub') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('P')) |
| | y.appendChild(mo) |
| | y.appendChild(self._print(e.args[0])) |
| | x.appendChild(y) |
| | x.appendChild(self._print(e.args[1:])) |
| | return x |
| |
|
| | def _print_assoc_legendre(self, e): |
| | x = self.dom.createElement('mrow') |
| | y = self.dom.createElement('msubsup') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('P')) |
| | y.appendChild(mo) |
| | y.appendChild(self._print(e.args[0])) |
| | y.appendChild(self._print(e.args[1:2])) |
| | x.appendChild(y) |
| | x.appendChild(self._print(e.args[2:])) |
| | return x |
| |
|
| | def _print_laguerre(self, e): |
| | x = self.dom.createElement('mrow') |
| | y = self.dom.createElement('msub') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('L')) |
| | y.appendChild(mo) |
| | y.appendChild(self._print(e.args[0])) |
| | x.appendChild(y) |
| | x.appendChild(self._print(e.args[1:])) |
| | return x |
| |
|
| | def _print_assoc_laguerre(self, e): |
| | x = self.dom.createElement('mrow') |
| | y = self.dom.createElement('msubsup') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('L')) |
| | y.appendChild(mo) |
| | y.appendChild(self._print(e.args[0])) |
| | y.appendChild(self._print(e.args[1:2])) |
| | x.appendChild(y) |
| | x.appendChild(self._print(e.args[2:])) |
| | return x |
| |
|
| | def _print_hermite(self, e): |
| | x = self.dom.createElement('mrow') |
| | y = self.dom.createElement('msub') |
| | mo = self.dom.createElement('mo') |
| | mo.appendChild(self.dom.createTextNode('H')) |
| | y.appendChild(mo) |
| | y.appendChild(self._print(e.args[0])) |
| | x.appendChild(y) |
| | x.appendChild(self._print(e.args[1:])) |
| | return x |
| |
|
| |
|
| | @print_function(MathMLPrinterBase) |
| | def mathml(expr, printer='content', **settings): |
| | """Returns the MathML representation of expr. If printer is presentation |
| | then prints Presentation MathML else prints content MathML. |
| | """ |
| | if printer == 'presentation': |
| | return MathMLPresentationPrinter(settings).doprint(expr) |
| | else: |
| | return MathMLContentPrinter(settings).doprint(expr) |
| |
|
| |
|
| | def print_mathml(expr, printer='content', **settings): |
| | """ |
| | Prints a pretty representation of the MathML code for expr. If printer is |
| | presentation then prints Presentation MathML else prints content MathML. |
| | |
| | Examples |
| | ======== |
| | |
| | >>> ## |
| | >>> from sympy import print_mathml |
| | >>> from sympy.abc import x |
| | >>> print_mathml(x+1) #doctest: +NORMALIZE_WHITESPACE |
| | <apply> |
| | <plus/> |
| | <ci>x</ci> |
| | <cn>1</cn> |
| | </apply> |
| | >>> print_mathml(x+1, printer='presentation') |
| | <mrow> |
| | <mi>x</mi> |
| | <mo>+</mo> |
| | <mn>1</mn> |
| | </mrow> |
| | |
| | """ |
| | if printer == 'presentation': |
| | s = MathMLPresentationPrinter(settings) |
| | else: |
| | s = MathMLContentPrinter(settings) |
| | xml = s._print(sympify(expr)) |
| | pretty_xml = xml.toprettyxml() |
| |
|
| | print(pretty_xml) |
| |
|
| |
|
| | |
| | MathMLPrinter = MathMLContentPrinter |
| |
|
