Add files using upload-large-folder tool

ckpts/universal/global_step80/zero/17.attention.query_key_value.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68f0995291896fb0c60bf50061a75e1e24302a5f6ec758f1297fefa2c595583a
+size 50332843

ckpts/universal/global_step80/zero/24.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:917a98408d3518dca6f23b61c93b96be4236af751f219fca4447feda8d625258
+size 33555627

ckpts/universal/global_step80/zero/24.mlp.dense_4h_to_h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d87eb2ec79a76f0787ddb5442faccf4d778f2acefd2f09fb5a6dc642323684aa
+size 33555533

ckpts/universal/global_step80/zero/25.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e906612ce58afd0156b8ba63deb18e2e4917017a4172fb76b0d4aedd39dc74b
+size 33555627

ckpts/universal/global_step80/zero/8.post_attention_layernorm.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18135723478193588f29e4a82749e5fd9a6fd160930ad51a65ef90b1a1528852
+size 9372

ckpts/universal/global_step80/zero/8.post_attention_layernorm.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21ad7a7d222d3ce6785a94348cf4cd95bc63274a114adb0229ba8ef316dda338
+size 9387

ckpts/universal/global_step80/zero/8.post_attention_layernorm.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60cd4e22cece5d8390f006a8c28ef20517902c794f98223d5fd98fdd9997d2d4
+size 9293

venv/lib/python3.10/site-packages/sympy/printing/conventions.py

@@ -0,0 +1,88 @@
+"""
+A few practical conventions common to all printers.
+"""
+
+import re
+
+from collections.abc import Iterable
+from sympy.core.function import Derivative
+
+_name_with_digits_p = re.compile(r'^([^\W\d_]+)(\d+)$', re.U)
+
+
+def split_super_sub(text):
+    """Split a symbol name into a name, superscripts and subscripts
+
+    The first part of the symbol name is considered to be its actual
+    'name', followed by super- and subscripts. Each superscript is
+    preceded with a "^" character or by "__". Each subscript is preceded
+    by a "_" character.  The three return values are the actual name, a
+    list with superscripts and a list with subscripts.
+
+    Examples
+    ========
+
+    >>> from sympy.printing.conventions import split_super_sub
+    >>> split_super_sub('a_x^1')
+    ('a', ['1'], ['x'])
+    >>> split_super_sub('var_sub1__sup_sub2')
+    ('var', ['sup'], ['sub1', 'sub2'])
+
+    """
+    if not text:
+        return text, [], []
+
+    pos = 0
+    name = None
+    supers = []
+    subs = []
+    while pos < len(text):
+        start = pos + 1
+        if text[pos:pos + 2] == "__":
+            start += 1
+        pos_hat = text.find("^", start)
+        if pos_hat < 0:
+            pos_hat = len(text)
+        pos_usc = text.find("_", start)
+        if pos_usc < 0:
+            pos_usc = len(text)
+        pos_next = min(pos_hat, pos_usc)
+        part = text[pos:pos_next]
+        pos = pos_next
+        if name is None:
+            name = part
+        elif part.startswith("^"):
+            supers.append(part[1:])
+        elif part.startswith("__"):
+            supers.append(part[2:])
+        elif part.startswith("_"):
+            subs.append(part[1:])
+        else:
+            raise RuntimeError("This should never happen.")
+
+    # Make a little exception when a name ends with digits, i.e. treat them
+    # as a subscript too.
+    m = _name_with_digits_p.match(name)
+    if m:
+        name, sub = m.groups()
+        subs.insert(0, sub)
+
+    return name, supers, subs
+
+
+def requires_partial(expr):
+    """Return whether a partial derivative symbol is required for printing
+
+    This requires checking how many free variables there are,
+    filtering out the ones that are integers. Some expressions do not have
+    free variables. In that case, check its variable list explicitly to
+    get the context of the expression.
+    """
+
+    if isinstance(expr, Derivative):
+        return requires_partial(expr.expr)
+
+    if not isinstance(expr.free_symbols, Iterable):
+        return len(set(expr.variables)) > 1
+
+    return sum(not s.is_integer for s in expr.free_symbols) > 1

venv/lib/python3.10/site-packages/sympy/printing/defaults.py

@@ -0,0 +1,5 @@
+from sympy.core._print_helpers import Printable
+
+# alias for compatibility
+Printable.__module__ = __name__
+DefaultPrinting = Printable

venv/lib/python3.10/site-packages/sympy/printing/fortran.py

@@ -0,0 +1,782 @@
+"""
+Fortran code printer
+
+The FCodePrinter converts single SymPy expressions into single Fortran
+expressions, using the functions defined in the Fortran 77 standard where
+possible. Some useful pointers to Fortran can be found on wikipedia:
+
+https://en.wikipedia.org/wiki/Fortran
+
+Most of the code below is based on the "Professional Programmer\'s Guide to
+Fortran77" by Clive G. Page:
+
+https://www.star.le.ac.uk/~cgp/prof77.html
+
+Fortran is a case-insensitive language. This might cause trouble because
+SymPy is case sensitive. So, fcode adds underscores to variable names when
+it is necessary to make them different for Fortran.
+"""
+
+from __future__ import annotations
+from typing import Any
+
+from collections import defaultdict
+from itertools import chain
+import string
+
+from sympy.codegen.ast import (
+    Assignment, Declaration, Pointer, value_const,
+    float32, float64, float80, complex64, complex128, int8, int16, int32,
+    int64, intc, real, integer,  bool_, complex_
+)
+from sympy.codegen.fnodes import (
+    allocatable, isign, dsign, cmplx, merge, literal_dp, elemental, pure,
+    intent_in, intent_out, intent_inout
+)
+from sympy.core import S, Add, N, Float, Symbol
+from sympy.core.function import Function
+from sympy.core.numbers import equal_valued
+from sympy.core.relational import Eq
+from sympy.sets import Range
+from sympy.printing.codeprinter import CodePrinter
+from sympy.printing.precedence import precedence, PRECEDENCE
+from sympy.printing.printer import printer_context
+
+# These are defined in the other file so we can avoid importing sympy.codegen
+# from the top-level 'import sympy'. Export them here as well.
+from sympy.printing.codeprinter import fcode, print_fcode # noqa:F401
+
+known_functions = {
+    "sin": "sin",
+    "cos": "cos",
+    "tan": "tan",
+    "asin": "asin",
+    "acos": "acos",
+    "atan": "atan",
+    "atan2": "atan2",
+    "sinh": "sinh",
+    "cosh": "cosh",
+    "tanh": "tanh",
+    "log": "log",
+    "exp": "exp",
+    "erf": "erf",
+    "Abs": "abs",
+    "conjugate": "conjg",
+    "Max": "max",
+    "Min": "min",
+}
+
+
+class FCodePrinter(CodePrinter):
+    """A printer to convert SymPy expressions to strings of Fortran code"""
+    printmethod = "_fcode"
+    language = "Fortran"
+
+    type_aliases = {
+        integer: int32,
+        real: float64,
+        complex_: complex128,
+    }
+
+    type_mappings = {
+        intc: 'integer(c_int)',
+        float32: 'real*4',  # real(kind(0.e0))
+        float64: 'real*8',  # real(kind(0.d0))
+        float80: 'real*10', # real(kind(????))
+        complex64: 'complex*8',
+        complex128: 'complex*16',
+        int8: 'integer*1',
+        int16: 'integer*2',
+        int32: 'integer*4',
+        int64: 'integer*8',
+        bool_: 'logical'
+    }
+
+    type_modules = {
+        intc: {'iso_c_binding': 'c_int'}
+    }
+
+    _default_settings: dict[str, Any] = {
+        'order': None,
+        'full_prec': 'auto',
+        'precision': 17,
+        'user_functions': {},
+        'human': True,
+        'allow_unknown_functions': False,
+        'source_format': 'fixed',
+        'contract': True,
+        'standard': 77,
+        'name_mangling': True,
+    }
+
+    _operators = {
+        'and': '.and.',
+        'or': '.or.',
+        'xor': '.neqv.',
+        'equivalent': '.eqv.',
+        'not': '.not. ',
+    }
+
+    _relationals = {
+        '!=': '/=',
+    }
+
+    def __init__(self, settings=None):
+        if not settings:
+            settings = {}
+        self.mangled_symbols = {}         # Dict showing mapping of all words
+        self.used_name = []
+        self.type_aliases = dict(chain(self.type_aliases.items(),
+                                       settings.pop('type_aliases', {}).items()))
+        self.type_mappings = dict(chain(self.type_mappings.items(),
+                                        settings.pop('type_mappings', {}).items()))
+        super().__init__(settings)
+        self.known_functions = dict(known_functions)
+        userfuncs = settings.get('user_functions', {})
+        self.known_functions.update(userfuncs)
+        # leading columns depend on fixed or free format
+        standards = {66, 77, 90, 95, 2003, 2008}
+        if self._settings['standard'] not in standards:
+            raise ValueError("Unknown Fortran standard: %s" % self._settings[
+                             'standard'])
+        self.module_uses = defaultdict(set)  # e.g.: use iso_c_binding, only: c_int
+
+    @property
+    def _lead(self):
+        if self._settings['source_format'] == 'fixed':
+            return {'code': "      ", 'cont': "     @ ", 'comment': "C     "}
+        elif self._settings['source_format'] == 'free':
+            return {'code': "", 'cont': "      ", 'comment': "! "}
+        else:
+            raise ValueError("Unknown source format: %s" % self._settings['source_format'])
+
+    def _print_Symbol(self, expr):
+        if self._settings['name_mangling'] == True:
+            if expr not in self.mangled_symbols:
+                name = expr.name
+                while name.lower() in self.used_name:
+                    name += '_'
+                self.used_name.append(name.lower())
+                if name == expr.name:
+                    self.mangled_symbols[expr] = expr
+                else:
+                    self.mangled_symbols[expr] = Symbol(name)
+
+            expr = expr.xreplace(self.mangled_symbols)
+
+        name = super()._print_Symbol(expr)
+        return name
+
+    def _rate_index_position(self, p):
+        return -p*5
+
+    def _get_statement(self, codestring):
+        return codestring
+
+    def _get_comment(self, text):
+        return "! {}".format(text)
+
+    def _declare_number_const(self, name, value):
+        return "parameter ({} = {})".format(name, self._print(value))
+
+    def _print_NumberSymbol(self, expr):
+        # A Number symbol that is not implemented here or with _printmethod
+        # is registered and evaluated
+        self._number_symbols.add((expr, Float(expr.evalf(self._settings['precision']))))
+        return str(expr)
+
+    def _format_code(self, lines):
+        return self._wrap_fortran(self.indent_code(lines))
+
+    def _traverse_matrix_indices(self, mat):
+        rows, cols = mat.shape
+        return ((i, j) for j in range(cols) for i in range(rows))
+
+    def _get_loop_opening_ending(self, indices):
+        open_lines = []
+        close_lines = []
+        for i in indices:
+            # fortran arrays start at 1 and end at dimension
+            var, start, stop = map(self._print,
+                    [i.label, i.lower + 1, i.upper + 1])
+            open_lines.append("do %s = %s, %s" % (var, start, stop))
+            close_lines.append("end do")
+        return open_lines, close_lines
+
+    def _print_sign(self, expr):
+        from sympy.functions.elementary.complexes import Abs
+        arg, = expr.args
+        if arg.is_integer:
+            new_expr = merge(0, isign(1, arg), Eq(arg, 0))
+        elif (arg.is_complex or arg.is_infinite):
+            new_expr = merge(cmplx(literal_dp(0), literal_dp(0)), arg/Abs(arg), Eq(Abs(arg), literal_dp(0)))
+        else:
+            new_expr = merge(literal_dp(0), dsign(literal_dp(1), arg), Eq(arg, literal_dp(0)))
+        return self._print(new_expr)
+
+
+    def _print_Piecewise(self, expr):
+        if expr.args[-1].cond != True:
+            # We need the last conditional to be a True, otherwise the resulting
+            # function may not return a result.
+            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.")
+        lines = []
+        if expr.has(Assignment):
+            for i, (e, c) in enumerate(expr.args):
+                if i == 0:
+                    lines.append("if (%s) then" % self._print(c))
+                elif i == len(expr.args) - 1 and c == True:
+                    lines.append("else")
+                else:
+                    lines.append("else if (%s) then" % self._print(c))
+                lines.append(self._print(e))
+            lines.append("end if")
+            return "\n".join(lines)
+        elif self._settings["standard"] >= 95:
+            # Only supported in F95 and newer:
+            # The piecewise was used in an expression, need to do inline
+            # operators. This has the downside that inline operators will
+            # not work for statements that span multiple lines (Matrix or
+            # Indexed expressions).
+            pattern = "merge({T}, {F}, {COND})"
+            code = self._print(expr.args[-1].expr)
+            terms = list(expr.args[:-1])
+            while terms:
+                e, c = terms.pop()
+                expr = self._print(e)
+                cond = self._print(c)
+                code = pattern.format(T=expr, F=code, COND=cond)
+            return code
+        else:
+            # `merge` is not supported prior to F95
+            raise NotImplementedError("Using Piecewise as an expression using "
+                                      "inline operators is not supported in "
+                                      "standards earlier than Fortran95.")
+
+    def _print_MatrixElement(self, expr):
+        return "{}({}, {})".format(self.parenthesize(expr.parent,
+                PRECEDENCE["Atom"], strict=True), expr.i + 1, expr.j + 1)
+
+    def _print_Add(self, expr):
+        # purpose: print complex numbers nicely in Fortran.
+        # collect the purely real and purely imaginary parts:
+        pure_real = []
+        pure_imaginary = []
+        mixed = []
+        for arg in expr.args:
+            if arg.is_number and arg.is_real:
+                pure_real.append(arg)
+            elif arg.is_number and arg.is_imaginary:
+                pure_imaginary.append(arg)
+            else:
+                mixed.append(arg)
+        if pure_imaginary:
+            if mixed:
+                PREC = precedence(expr)
+                term = Add(*mixed)
+                t = self._print(term)
+                if t.startswith('-'):
+                    sign = "-"
+                    t = t[1:]
+                else:
+                    sign = "+"
+                if precedence(term) < PREC:
+                    t = "(%s)" % t
+
+                return "cmplx(%s,%s) %s %s" % (
+                    self._print(Add(*pure_real)),
+                    self._print(-S.ImaginaryUnit*Add(*pure_imaginary)),
+                    sign, t,
+                )
+            else:
+                return "cmplx(%s,%s)" % (
+                    self._print(Add(*pure_real)),
+                    self._print(-S.ImaginaryUnit*Add(*pure_imaginary)),
+                )
+        else:
+            return CodePrinter._print_Add(self, expr)
+
+    def _print_Function(self, expr):
+        # All constant function args are evaluated as floats
+        prec =  self._settings['precision']
+        args = [N(a, prec) for a in expr.args]
+        eval_expr = expr.func(*args)
+        if not isinstance(eval_expr, Function):
+            return self._print(eval_expr)
+        else:
+            return CodePrinter._print_Function(self, expr.func(*args))
+
+    def _print_Mod(self, expr):
+        # NOTE : Fortran has the functions mod() and modulo(). modulo() behaves
+        # the same wrt to the sign of the arguments as Python and SymPy's
+        # modulus computations (% and Mod()) but is not available in Fortran 66
+        # or Fortran 77, thus we raise an error.
+        if self._settings['standard'] in [66, 77]:
+            msg = ("Python % operator and SymPy's Mod() function are not "
+                   "supported by Fortran 66 or 77 standards.")
+            raise NotImplementedError(msg)
+        else:
+            x, y = expr.args
+            return "      modulo({}, {})".format(self._print(x), self._print(y))
+
+    def _print_ImaginaryUnit(self, expr):
+        # purpose: print complex numbers nicely in Fortran.
+        return "cmplx(0,1)"
+
+    def _print_int(self, expr):
+        return str(expr)
+
+    def _print_Mul(self, expr):
+        # purpose: print complex numbers nicely in Fortran.
+        if expr.is_number and expr.is_imaginary:
+            return "cmplx(0,%s)" % (
+                self._print(-S.ImaginaryUnit*expr)
+            )
+        else:
+            return CodePrinter._print_Mul(self, expr)
+
+    def _print_Pow(self, expr):
+        PREC = precedence(expr)
+        if equal_valued(expr.exp, -1):
+            return '%s/%s' % (
+                self._print(literal_dp(1)),
+                self.parenthesize(expr.base, PREC)
+            )
+        elif equal_valued(expr.exp, 0.5):
+            if expr.base.is_integer:
+                # Fortran intrinsic sqrt() does not accept integer argument
+                if expr.base.is_Number:
+                    return 'sqrt(%s.0d0)' % self._print(expr.base)
+                else:
+                    return 'sqrt(dble(%s))' % self._print(expr.base)
+            else:
+                return 'sqrt(%s)' % self._print(expr.base)
+        else:
+            return CodePrinter._print_Pow(self, expr)
+
+    def _print_Rational(self, expr):
+        p, q = int(expr.p), int(expr.q)
+        return "%d.0d0/%d.0d0" % (p, q)
+
+    def _print_Float(self, expr):
+        printed = CodePrinter._print_Float(self, expr)
+        e = printed.find('e')
+        if e > -1:
+            return "%sd%s" % (printed[:e], printed[e + 1:])
+        return "%sd0" % printed
+
+    def _print_Relational(self, expr):
+        lhs_code = self._print(expr.lhs)
+        rhs_code = self._print(expr.rhs)
+        op = expr.rel_op
+        op = op if op not in self._relationals else self._relationals[op]
+        return "{} {} {}".format(lhs_code, op, rhs_code)
+
+    def _print_Indexed(self, expr):
+        inds = [ self._print(i) for i in expr.indices ]
+        return "%s(%s)" % (self._print(expr.base.label), ", ".join(inds))
+
+    def _print_Idx(self, expr):
+        return self._print(expr.label)
+
+    def _print_AugmentedAssignment(self, expr):
+        lhs_code = self._print(expr.lhs)
+        rhs_code = self._print(expr.rhs)
+        return self._get_statement("{0} = {0} {1} {2}".format(
+            self._print(lhs_code), self._print(expr.binop), self._print(rhs_code)))
+
+    def _print_sum_(self, sm):
+        params = self._print(sm.array)
+        if sm.dim != None: # Must use '!= None', cannot use 'is not None'
+            params += ', ' + self._print(sm.dim)
+        if sm.mask != None: # Must use '!= None', cannot use 'is not None'
+            params += ', mask=' + self._print(sm.mask)
+        return '%s(%s)' % (sm.__class__.__name__.rstrip('_'), params)
+
+    def _print_product_(self, prod):
+        return self._print_sum_(prod)
+
+    def _print_Do(self, do):
+        excl = ['concurrent']
+        if do.step == 1:
+            excl.append('step')
+            step = ''
+        else:
+            step = ', {step}'
+
+        return (
+            'do {concurrent}{counter} = {first}, {last}'+step+'\n'
+            '{body}\n'
+            'end do\n'
+        ).format(
+            concurrent='concurrent ' if do.concurrent else '',
+            **do.kwargs(apply=lambda arg: self._print(arg), exclude=excl)
+        )
+
+    def _print_ImpliedDoLoop(self, idl):
+        step = '' if idl.step == 1 else ', {step}'
+        return ('({expr}, {counter} = {first}, {last}'+step+')').format(
+            **idl.kwargs(apply=lambda arg: self._print(arg))
+        )
+
+    def _print_For(self, expr):
+        target = self._print(expr.target)
+        if isinstance(expr.iterable, Range):
+            start, stop, step = expr.iterable.args
+        else:
+            raise NotImplementedError("Only iterable currently supported is Range")
+        body = self._print(expr.body)
+        return ('do {target} = {start}, {stop}, {step}\n'
+                '{body}\n'
+                'end do').format(target=target, start=start, stop=stop - 1,
+                        step=step, body=body)
+
+    def _print_Type(self, type_):
+        type_ = self.type_aliases.get(type_, type_)
+        type_str = self.type_mappings.get(type_, type_.name)
+        module_uses = self.type_modules.get(type_)
+        if module_uses:
+            for k, v in module_uses:
+                self.module_uses[k].add(v)
+        return type_str
+
+    def _print_Element(self, elem):
+        return '{symbol}({idxs})'.format(
+            symbol=self._print(elem.symbol),
+            idxs=', '.join((self._print(arg) for arg in elem.indices))
+        )
+
+    def _print_Extent(self, ext):
+        return str(ext)
+
+    def _print_Declaration(self, expr):
+        var = expr.variable
+        val = var.value
+        dim = var.attr_params('dimension')
+        intents = [intent in var.attrs for intent in (intent_in, intent_out, intent_inout)]
+        if intents.count(True) == 0:
+            intent = ''
+        elif intents.count(True) == 1:
+            intent = ', intent(%s)' % ['in', 'out', 'inout'][intents.index(True)]
+        else:
+            raise ValueError("Multiple intents specified for %s" % self)
+
+        if isinstance(var, Pointer):
+            raise NotImplementedError("Pointers are not available by default in Fortran.")
+        if self._settings["standard"] >= 90:
+            result = '{t}{vc}{dim}{intent}{alloc} :: {s}'.format(
+                t=self._print(var.type),
+                vc=', parameter' if value_const in var.attrs else '',
+                dim=', dimension(%s)' % ', '.join((self._print(arg) for arg in dim)) if dim else '',
+                intent=intent,
+                alloc=', allocatable' if allocatable in var.attrs else '',
+                s=self._print(var.symbol)
+            )
+            if val != None: # Must be "!= None", cannot be "is not None"
+                result += ' = %s' % self._print(val)
+        else:
+            if value_const in var.attrs or val:
+                raise NotImplementedError("F77 init./parameter statem. req. multiple lines.")
+            result = ' '.join((self._print(arg) for arg in [var.type, var.symbol]))
+
+        return result
+
+
+    def _print_Infinity(self, expr):
+        return '(huge(%s) + 1)' % self._print(literal_dp(0))
+
+    def _print_While(self, expr):
+        return 'do while ({condition})\n{body}\nend do'.format(**expr.kwargs(
+            apply=lambda arg: self._print(arg)))
+
+    def _print_BooleanTrue(self, expr):
+        return '.true.'
+
+    def _print_BooleanFalse(self, expr):
+        return '.false.'
+
+    def _pad_leading_columns(self, lines):
+        result = []
+        for line in lines:
+            if line.startswith('!'):
+                result.append(self._lead['comment'] + line[1:].lstrip())
+            else:
+                result.append(self._lead['code'] + line)
+        return result
+
+    def _wrap_fortran(self, lines):
+        """Wrap long Fortran lines
+
+           Argument:
+             lines  --  a list of lines (without \\n character)
+
+           A comment line is split at white space. Code lines are split with a more
+           complex rule to give nice results.
+        """
+        # routine to find split point in a code line
+        my_alnum = set("_+-." + string.digits + string.ascii_letters)
+        my_white = set(" \t()")
+
+        def split_pos_code(line, endpos):
+            if len(line) <= endpos:
+                return len(line)
+            pos = endpos
+            split = lambda pos: \
+                (line[pos] in my_alnum and line[pos - 1] not in my_alnum) or \
+                (line[pos] not in my_alnum and line[pos - 1] in my_alnum) or \
+                (line[pos] in my_white and line[pos - 1] not in my_white) or \
+                (line[pos] not in my_white and line[pos - 1] in my_white)
+            while not split(pos):
+                pos -= 1
+                if pos == 0:
+                    return endpos
+            return pos
+        # split line by line and add the split lines to result
+        result = []
+        if self._settings['source_format'] == 'free':
+            trailing = ' &'
+        else:
+            trailing = ''
+        for line in lines:
+            if line.startswith(self._lead['comment']):
+                # comment line
+                if len(line) > 72:
+                    pos = line.rfind(" ", 6, 72)
+                    if pos == -1:
+                        pos = 72
+                    hunk = line[:pos]
+                    line = line[pos:].lstrip()
+                    result.append(hunk)
+                    while line:
+                        pos = line.rfind(" ", 0, 66)
+                        if pos == -1 or len(line) < 66:
+                            pos = 66
+                        hunk = line[:pos]
+                        line = line[pos:].lstrip()
+                        result.append("%s%s" % (self._lead['comment'], hunk))
+                else:
+                    result.append(line)
+            elif line.startswith(self._lead['code']):
+                # code line
+                pos = split_pos_code(line, 72)
+                hunk = line[:pos].rstrip()
+                line = line[pos:].lstrip()
+                if line:
+                    hunk += trailing
+                result.append(hunk)
+                while line:
+                    pos = split_pos_code(line, 65)
+                    hunk = line[:pos].rstrip()
+                    line = line[pos:].lstrip()
+                    if line:
+                        hunk += trailing
+                    result.append("%s%s" % (self._lead['cont'], hunk))
+            else:
+                result.append(line)
+        return result
+
+    def indent_code(self, code):
+        """Accepts a string of code or a list of code lines"""
+        if isinstance(code, str):
+            code_lines = self.indent_code(code.splitlines(True))
+            return ''.join(code_lines)
+
+        free = self._settings['source_format'] == 'free'
+        code = [ line.lstrip(' \t') for line in code ]
+
+        inc_keyword = ('do ', 'if(', 'if ', 'do\n', 'else', 'program', 'interface')
+        dec_keyword = ('end do', 'enddo', 'end if', 'endif', 'else', 'end program', 'end interface')
+
+        increase = [ int(any(map(line.startswith, inc_keyword)))
+                     for line in code ]
+        decrease = [ int(any(map(line.startswith, dec_keyword)))
+                     for line in code ]
+        continuation = [ int(any(map(line.endswith, ['&', '&\n'])))
+                         for line in code ]
+
+        level = 0
+        cont_padding = 0
+        tabwidth = 3
+        new_code = []
+        for i, line in enumerate(code):
+            if line in ('', '\n'):
+                new_code.append(line)
+                continue
+            level -= decrease[i]
+
+            if free:
+                padding = " "*(level*tabwidth + cont_padding)
+            else:
+                padding = " "*level*tabwidth
+
+            line = "%s%s" % (padding, line)
+            if not free:
+                line = self._pad_leading_columns([line])[0]
+
+            new_code.append(line)
+
+            if continuation[i]:
+                cont_padding = 2*tabwidth
+            else:
+                cont_padding = 0
+            level += increase[i]
+
+        if not free:
+            return self._wrap_fortran(new_code)
+        return new_code
+
+    def _print_GoTo(self, goto):
+        if goto.expr:  # computed goto
+            return "go to ({labels}), {expr}".format(
+                labels=', '.join((self._print(arg) for arg in goto.labels)),
+                expr=self._print(goto.expr)
+            )
+        else:
+            lbl, = goto.labels
+            return "go to %s" % self._print(lbl)
+
+    def _print_Program(self, prog):
+        return (
+            "program {name}\n"
+            "{body}\n"
+            "end program\n"
+        ).format(**prog.kwargs(apply=lambda arg: self._print(arg)))
+
+    def _print_Module(self, mod):
+        return (
+            "module {name}\n"
+            "{declarations}\n"
+            "\ncontains\n\n"
+            "{definitions}\n"
+            "end module\n"
+        ).format(**mod.kwargs(apply=lambda arg: self._print(arg)))
+
+    def _print_Stream(self, strm):
+        if strm.name == 'stdout' and self._settings["standard"] >= 2003:
+            self.module_uses['iso_c_binding'].add('stdint=>input_unit')
+            return 'input_unit'
+        elif strm.name == 'stderr' and self._settings["standard"] >= 2003:
+            self.module_uses['iso_c_binding'].add('stdint=>error_unit')
+            return 'error_unit'
+        else:
+            if strm.name == 'stdout':
+                return '*'
+            else:
+                return strm.name
+
+    def _print_Print(self, ps):
+        if ps.format_string != None: # Must be '!= None', cannot be 'is not None'
+            fmt = self._print(ps.format_string)
+        else:
+            fmt = "*"
+        return "print {fmt}, {iolist}".format(fmt=fmt, iolist=', '.join(
+            (self._print(arg) for arg in ps.print_args)))
+
+    def _print_Return(self, rs):
+        arg, = rs.args
+        return "{result_name} = {arg}".format(
+            result_name=self._context.get('result_name', 'sympy_result'),
+            arg=self._print(arg)
+        )
+
+    def _print_FortranReturn(self, frs):
+        arg, = frs.args
+        if arg:
+            return 'return %s' % self._print(arg)
+        else:
+            return 'return'
+
+    def _head(self, entity, fp, **kwargs):
+        bind_C_params = fp.attr_params('bind_C')
+        if bind_C_params is None:
+            bind = ''
+        else:
+            bind = ' bind(C, name="%s")' % bind_C_params[0] if bind_C_params else ' bind(C)'
+        result_name = self._settings.get('result_name', None)
+        return (
+            "{entity}{name}({arg_names}){result}{bind}\n"
+            "{arg_declarations}"
+        ).format(
+            entity=entity,
+            name=self._print(fp.name),
+            arg_names=', '.join([self._print(arg.symbol) for arg in fp.parameters]),
+            result=(' result(%s)' % result_name) if result_name else '',
+            bind=bind,
+            arg_declarations='\n'.join((self._print(Declaration(arg)) for arg in fp.parameters))
+        )
+
+    def _print_FunctionPrototype(self, fp):
+        entity = "{} function ".format(self._print(fp.return_type))
+        return (
+            "interface\n"
+            "{function_head}\n"
+            "end function\n"
+            "end interface"
+        ).format(function_head=self._head(entity, fp))
+
+    def _print_FunctionDefinition(self, fd):
+        if elemental in fd.attrs:
+            prefix = 'elemental '
+        elif pure in fd.attrs:
+            prefix = 'pure '
+        else:
+            prefix = ''
+
+        entity = "{} function ".format(self._print(fd.return_type))
+        with printer_context(self, result_name=fd.name):
+            return (
+                "{prefix}{function_head}\n"
+                "{body}\n"
+                "end function\n"
+            ).format(
+                prefix=prefix,
+                function_head=self._head(entity, fd),
+                body=self._print(fd.body)
+            )
+
+    def _print_Subroutine(self, sub):
+        return (
+            '{subroutine_head}\n'
+            '{body}\n'
+            'end subroutine\n'
+        ).format(
+            subroutine_head=self._head('subroutine ', sub),
+            body=self._print(sub.body)
+        )
+
+    def _print_SubroutineCall(self, scall):
+        return 'call {name}({args})'.format(
+            name=self._print(scall.name),
+            args=', '.join((self._print(arg) for arg in scall.subroutine_args))
+        )
+
+    def _print_use_rename(self, rnm):
+        return "%s => %s" % tuple((self._print(arg) for arg in rnm.args))
+
+    def _print_use(self, use):
+        result = 'use %s' % self._print(use.namespace)
+        if use.rename != None: # Must be '!= None', cannot be 'is not None'
+            result += ', ' + ', '.join([self._print(rnm) for rnm in use.rename])
+        if use.only != None: # Must be '!= None', cannot be 'is not None'
+            result += ', only: ' + ', '.join([self._print(nly) for nly in use.only])
+        return result
+
+    def _print_BreakToken(self, _):
+        return 'exit'
+
+    def _print_ContinueToken(self, _):
+        return 'cycle'
+
+    def _print_ArrayConstructor(self, ac):
+        fmtstr = "[%s]" if self._settings["standard"] >= 2003 else '(/%s/)'
+        return fmtstr % ', '.join((self._print(arg) for arg in ac.elements))
+
+    def _print_ArrayElement(self, elem):
+        return '{symbol}({idxs})'.format(
+            symbol=self._print(elem.name),
+            idxs=', '.join((self._print(arg) for arg in elem.indices))
+        )

venv/lib/python3.10/site-packages/sympy/printing/jscode.py

@@ -0,0 +1,339 @@
+"""
+Javascript code printer
+
+The JavascriptCodePrinter converts single SymPy expressions into single
+Javascript expressions, using the functions defined in the Javascript
+Math object where possible.
+
+"""
+
+from __future__ import annotations
+from typing import Any
+
+from sympy.core import S
+from sympy.core.numbers import equal_valued
+from sympy.printing.codeprinter import CodePrinter
+from sympy.printing.precedence import precedence, PRECEDENCE
+
+
+# dictionary mapping SymPy function to (argument_conditions, Javascript_function).
+# Used in JavascriptCodePrinter._print_Function(self)
+known_functions = {
+    'Abs': 'Math.abs',
+    'acos': 'Math.acos',
+    'acosh': 'Math.acosh',
+    'asin': 'Math.asin',
+    'asinh': 'Math.asinh',
+    'atan': 'Math.atan',
+    'atan2': 'Math.atan2',
+    'atanh': 'Math.atanh',
+    'ceiling': 'Math.ceil',
+    'cos': 'Math.cos',
+    'cosh': 'Math.cosh',
+    'exp': 'Math.exp',
+    'floor': 'Math.floor',
+    'log': 'Math.log',
+    'Max': 'Math.max',
+    'Min': 'Math.min',
+    'sign': 'Math.sign',
+    'sin': 'Math.sin',
+    'sinh': 'Math.sinh',
+    'tan': 'Math.tan',
+    'tanh': 'Math.tanh',
+}
+
+
+class JavascriptCodePrinter(CodePrinter):
+    """"A Printer to convert Python expressions to strings of JavaScript code
+    """
+    printmethod = '_javascript'
+    language = 'JavaScript'
+
+    _default_settings: dict[str, Any] = {
+        'order': None,
+        'full_prec': 'auto',
+        'precision': 17,
+        'user_functions': {},
+        'human': True,
+        'allow_unknown_functions': False,
+        'contract': True,
+    }
+
+    def __init__(self, settings={}):
+        CodePrinter.__init__(self, settings)
+        self.known_functions = dict(known_functions)
+        userfuncs = settings.get('user_functions', {})
+        self.known_functions.update(userfuncs)
+
+    def _rate_index_position(self, p):
+        return p*5
+
+    def _get_statement(self, codestring):
+        return "%s;" % codestring
+
+    def _get_comment(self, text):
+        return "// {}".format(text)
+
+    def _declare_number_const(self, name, value):
+        return "var {} = {};".format(name, value.evalf(self._settings['precision']))
+
+    def _format_code(self, lines):
+        return self.indent_code(lines)
+
+    def _traverse_matrix_indices(self, mat):
+        rows, cols = mat.shape
+        return ((i, j) for i in range(rows) for j in range(cols))
+
+    def _get_loop_opening_ending(self, indices):
+        open_lines = []
+        close_lines = []
+        loopstart = "for (var %(varble)s=%(start)s; %(varble)s<%(end)s; %(varble)s++){"
+        for i in indices:
+            # Javascript arrays start at 0 and end at dimension-1
+            open_lines.append(loopstart % {
+                'varble': self._print(i.label),
+                'start': self._print(i.lower),
+                'end': self._print(i.upper + 1)})
+            close_lines.append("}")
+        return open_lines, close_lines
+
+    def _print_Pow(self, expr):
+        PREC = precedence(expr)
+        if equal_valued(expr.exp, -1):
+            return '1/%s' % (self.parenthesize(expr.base, PREC))
+        elif equal_valued(expr.exp, 0.5):
+            return 'Math.sqrt(%s)' % self._print(expr.base)
+        elif expr.exp == S.One/3:
+            return 'Math.cbrt(%s)' % self._print(expr.base)
+        else:
+            return 'Math.pow(%s, %s)' % (self._print(expr.base),
+                                 self._print(expr.exp))
+
+    def _print_Rational(self, expr):
+        p, q = int(expr.p), int(expr.q)
+        return '%d/%d' % (p, q)
+
+    def _print_Mod(self, expr):
+        num, den = expr.args
+        PREC = precedence(expr)
+        snum, sden = [self.parenthesize(arg, PREC) for arg in expr.args]
+        # % is remainder (same sign as numerator), not modulo (same sign as
+        # denominator), in js. Hence, % only works as modulo if both numbers
+        # have the same sign
+        if (num.is_nonnegative and den.is_nonnegative or
+            num.is_nonpositive and den.is_nonpositive):
+            return f"{snum} % {sden}"
+        return f"(({snum} % {sden}) + {sden}) % {sden}"
+
+    def _print_Relational(self, expr):
+        lhs_code = self._print(expr.lhs)
+        rhs_code = self._print(expr.rhs)
+        op = expr.rel_op
+        return "{} {} {}".format(lhs_code, op, rhs_code)
+
+    def _print_Indexed(self, expr):
+        # calculate index for 1d array
+        dims = expr.shape
+        elem = S.Zero
+        offset = S.One
+        for i in reversed(range(expr.rank)):
+            elem += expr.indices[i]*offset
+            offset *= dims[i]
+        return "%s[%s]" % (self._print(expr.base.label), self._print(elem))
+
+    def _print_Idx(self, expr):
+        return self._print(expr.label)
+
+    def _print_Exp1(self, expr):
+        return "Math.E"
+
+    def _print_Pi(self, expr):
+        return 'Math.PI'
+
+    def _print_Infinity(self, expr):
+        return 'Number.POSITIVE_INFINITY'
+
+    def _print_NegativeInfinity(self, expr):
+        return 'Number.NEGATIVE_INFINITY'
+
+    def _print_Piecewise(self, expr):
+        from sympy.codegen.ast import Assignment
+        if expr.args[-1].cond != True:
+            # We need the last conditional to be a True, otherwise the resulting
+            # function may not return a result.
+            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.")
+        lines = []
+        if expr.has(Assignment):
+            for i, (e, c) in enumerate(expr.args):
+                if i == 0:
+                    lines.append("if (%s) {" % self._print(c))
+                elif i == len(expr.args) - 1 and c == True:
+                    lines.append("else {")
+                else:
+                    lines.append("else if (%s) {" % self._print(c))
+                code0 = self._print(e)
+                lines.append(code0)
+                lines.append("}")
+            return "\n".join(lines)
+        else:
+            # The piecewise was used in an expression, need to do inline
+            # operators. This has the downside that inline operators will
+            # not work for statements that span multiple lines (Matrix or
+            # Indexed expressions).
+            ecpairs = ["((%s) ? (\n%s\n)\n" % (self._print(c), self._print(e))
+                    for e, c in expr.args[:-1]]
+            last_line = ": (\n%s\n)" % self._print(expr.args[-1].expr)
+            return ": ".join(ecpairs) + last_line + " ".join([")"*len(ecpairs)])
+
+    def _print_MatrixElement(self, expr):
+        return "{}[{}]".format(self.parenthesize(expr.parent,
+            PRECEDENCE["Atom"], strict=True),
+            expr.j + expr.i*expr.parent.shape[1])
+
+    def indent_code(self, code):
+        """Accepts a string of code or a list of code lines"""
+
+        if isinstance(code, str):
+            code_lines = self.indent_code(code.splitlines(True))
+            return ''.join(code_lines)
+
+        tab = "   "
+        inc_token = ('{', '(', '{\n', '(\n')
+        dec_token = ('}', ')')
+
+        code = [ line.lstrip(' \t') for line in code ]
+
+        increase = [ int(any(map(line.endswith, inc_token))) for line in code ]
+        decrease = [ int(any(map(line.startswith, dec_token)))
+                     for line in code ]
+
+        pretty = []
+        level = 0
+        for n, line in enumerate(code):
+            if line in ('', '\n'):
+                pretty.append(line)
+                continue
+            level -= decrease[n]
+            pretty.append("%s%s" % (tab*level, line))
+            level += increase[n]
+        return pretty
+
+
+def jscode(expr, assign_to=None, **settings):
+    """Converts an expr to a string of javascript code
+
+    Parameters
+    ==========
+
+    expr : Expr
+        A SymPy expression to be converted.
+    assign_to : optional
+        When given, the argument is used as the name of the variable to which
+        the expression is assigned. Can be a string, ``Symbol``,
+        ``MatrixSymbol``, or ``Indexed`` type. This is helpful in case of
+        line-wrapping, or for expressions that generate multi-line statements.
+    precision : integer, optional
+        The precision for numbers such as pi [default=15].
+    user_functions : dict, optional
+        A dictionary where keys are ``FunctionClass`` instances and values are
+        their string representations. Alternatively, the dictionary value can
+        be a list of tuples i.e. [(argument_test, js_function_string)]. See
+        below for examples.
+    human : bool, optional
+        If True, the result is a single string that may contain some constant
+        declarations for the number symbols. If False, the same information is
+        returned in a tuple of (symbols_to_declare, not_supported_functions,
+        code_text). [default=True].
+    contract: bool, optional
+        If True, ``Indexed`` instances are assumed to obey tensor contraction
+        rules and the corresponding nested loops over indices are generated.
+        Setting contract=False will not generate loops, instead the user is
+        responsible to provide values for the indices in the code.
+        [default=True].
+
+    Examples
+    ========
+
+    >>> from sympy import jscode, symbols, Rational, sin, ceiling, Abs
+    >>> x, tau = symbols("x, tau")
+    >>> jscode((2*tau)**Rational(7, 2))
+    '8*Math.sqrt(2)*Math.pow(tau, 7/2)'
+    >>> jscode(sin(x), assign_to="s")
+    's = Math.sin(x);'
+
+    Custom printing can be defined for certain types by passing a dictionary of
+    "type" : "function" to the ``user_functions`` kwarg. Alternatively, the
+    dictionary value can be a list of tuples i.e. [(argument_test,
+    js_function_string)].
+
+    >>> custom_functions = {
+    ...   "ceiling": "CEIL",
+    ...   "Abs": [(lambda x: not x.is_integer, "fabs"),
+    ...           (lambda x: x.is_integer, "ABS")]
+    ... }
+    >>> jscode(Abs(x) + ceiling(x), user_functions=custom_functions)
+    'fabs(x) + CEIL(x)'
+
+    ``Piecewise`` expressions are converted into conditionals. If an
+    ``assign_to`` variable is provided an if statement is created, otherwise
+    the ternary operator is used. Note that if the ``Piecewise`` lacks a
+    default term, represented by ``(expr, True)`` then an error will be thrown.
+    This is to prevent generating an expression that may not evaluate to
+    anything.
+
+    >>> from sympy import Piecewise
+    >>> expr = Piecewise((x + 1, x > 0), (x, True))
+    >>> print(jscode(expr, tau))
+    if (x > 0) {
+       tau = x + 1;
+    }
+    else {
+       tau = x;
+    }
+
+    Support for loops is provided through ``Indexed`` types. With
+    ``contract=True`` these expressions will be turned into loops, whereas
+    ``contract=False`` will just print the assignment expression that should be
+    looped over:
+
+    >>> from sympy import Eq, IndexedBase, Idx
+    >>> len_y = 5
+    >>> y = IndexedBase('y', shape=(len_y,))
+    >>> t = IndexedBase('t', shape=(len_y,))
+    >>> Dy = IndexedBase('Dy', shape=(len_y-1,))
+    >>> i = Idx('i', len_y-1)
+    >>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i]))
+    >>> jscode(e.rhs, assign_to=e.lhs, contract=False)
+    'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);'
+
+    Matrices are also supported, but a ``MatrixSymbol`` of the same dimensions
+    must be provided to ``assign_to``. Note that any expression that can be
+    generated normally can also exist inside a Matrix:
+
+    >>> from sympy import Matrix, MatrixSymbol
+    >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)])
+    >>> A = MatrixSymbol('A', 3, 1)
+    >>> print(jscode(mat, A))
+    A[0] = Math.pow(x, 2);
+    if (x > 0) {
+       A[1] = x + 1;
+    }
+    else {
+       A[1] = x;
+    }
+    A[2] = Math.sin(x);
+    """
+
+    return JavascriptCodePrinter(settings).doprint(expr, assign_to)
+
+
+def print_jscode(expr, **settings):
+    """Prints the Javascript representation of the given expression.
+
+       See jscode for the meaning of the optional arguments.
+    """
+    print(jscode(expr, **settings))

venv/lib/python3.10/site-packages/sympy/printing/maple.py

@@ -0,0 +1,311 @@
+"""
+Maple code printer
+
+The MapleCodePrinter converts single SymPy expressions into single
+Maple expressions, using the functions defined in the Maple objects where possible.
+
+
+FIXME: This module is still under actively developed. Some functions may be not completed.
+"""
+
+from sympy.core import S
+from sympy.core.numbers import Integer, IntegerConstant, equal_valued
+from sympy.printing.codeprinter import CodePrinter
+from sympy.printing.precedence import precedence, PRECEDENCE
+
+import sympy
+
+_known_func_same_name = (
+    'sin', 'cos', 'tan', 'sec', 'csc', 'cot', 'sinh', 'cosh', 'tanh', 'sech',
+    'csch', 'coth', 'exp', 'floor', 'factorial', 'bernoulli',  'euler',
+    'fibonacci', 'gcd', 'lcm', 'conjugate', 'Ci', 'Chi', 'Ei', 'Li', 'Si', 'Shi',
+    'erf', 'erfc', 'harmonic', 'LambertW',
+    'sqrt', # For automatic rewrites
+)
+
+known_functions = {
+    # SymPy -> Maple
+    'Abs': 'abs',
+    'log': 'ln',
+    'asin': 'arcsin',
+    'acos': 'arccos',
+    'atan': 'arctan',
+    'asec': 'arcsec',
+    'acsc': 'arccsc',
+    'acot': 'arccot',
+    'asinh': 'arcsinh',
+    'acosh': 'arccosh',
+    'atanh': 'arctanh',
+    'asech': 'arcsech',
+    'acsch': 'arccsch',
+    'acoth': 'arccoth',
+    'ceiling': 'ceil',
+    'Max' : 'max',
+    'Min' : 'min',
+
+    'factorial2': 'doublefactorial',
+    'RisingFactorial': 'pochhammer',
+    'besseli': 'BesselI',
+    'besselj': 'BesselJ',
+    'besselk': 'BesselK',
+    'bessely': 'BesselY',
+    'hankelh1': 'HankelH1',
+    'hankelh2': 'HankelH2',
+    'airyai': 'AiryAi',
+    'airybi': 'AiryBi',
+    'appellf1': 'AppellF1',
+    'fresnelc': 'FresnelC',
+    'fresnels': 'FresnelS',
+    'lerchphi' : 'LerchPhi',
+}
+
+for _func in _known_func_same_name:
+    known_functions[_func] = _func
+
+number_symbols = {
+    # SymPy -> Maple
+    S.Pi: 'Pi',
+    S.Exp1: 'exp(1)',
+    S.Catalan: 'Catalan',
+    S.EulerGamma: 'gamma',
+    S.GoldenRatio: '(1/2 + (1/2)*sqrt(5))'
+}
+
+spec_relational_ops = {
+    # SymPy -> Maple
+    '==': '=',
+    '!=': '<>'
+}
+
+not_supported_symbol = [
+    S.ComplexInfinity
+]
+
+class MapleCodePrinter(CodePrinter):
+    """
+    Printer which converts a SymPy expression into a maple code.
+    """
+    printmethod = "_maple"
+    language = "maple"
+
+    _default_settings = {
+        'order': None,
+        'full_prec': 'auto',
+        'human': True,
+        'inline': True,
+        'allow_unknown_functions': True,
+    }
+
+    def __init__(self, settings=None):
+        if settings is None:
+            settings = {}
+        super().__init__(settings)
+        self.known_functions = dict(known_functions)
+        userfuncs = settings.get('user_functions', {})
+        self.known_functions.update(userfuncs)
+
+    def _get_statement(self, codestring):
+        return "%s;" % codestring
+
+    def _get_comment(self, text):
+        return "# {}".format(text)
+
+    def _declare_number_const(self, name, value):
+        return "{} := {};".format(name,
+                                    value.evalf(self._settings['precision']))
+
+    def _format_code(self, lines):
+        return lines
+
+    def _print_tuple(self, expr):
+        return self._print(list(expr))
+
+    def _print_Tuple(self, expr):
+        return self._print(list(expr))
+
+    def _print_Assignment(self, expr):
+        lhs = self._print(expr.lhs)
+        rhs = self._print(expr.rhs)
+        return "{lhs} := {rhs}".format(lhs=lhs, rhs=rhs)
+
+    def _print_Pow(self, expr, **kwargs):
+        PREC = precedence(expr)
+        if equal_valued(expr.exp, -1):
+            return '1/%s' % (self.parenthesize(expr.base, PREC))
+        elif equal_valued(expr.exp, 0.5):
+            return 'sqrt(%s)' % self._print(expr.base)
+        elif equal_valued(expr.exp, -0.5):
+            return '1/sqrt(%s)' % self._print(expr.base)
+        else:
+            return '{base}^{exp}'.format(
+                base=self.parenthesize(expr.base, PREC),
+                exp=self.parenthesize(expr.exp, PREC))
+
+    def _print_Piecewise(self, expr):
+        if (expr.args[-1].cond is not True) and (expr.args[-1].cond != S.BooleanTrue):
+            # We need the last conditional to be a True, otherwise the resulting
+            # function may not return a result.
+            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.")
+        _coup_list = [
+            ("{c}, {e}".format(c=self._print(c),
+                               e=self._print(e)) if c is not True and c is not S.BooleanTrue else "{e}".format(
+                e=self._print(e)))
+            for e, c in expr.args]
+        _inbrace = ', '.join(_coup_list)
+        return 'piecewise({_inbrace})'.format(_inbrace=_inbrace)
+
+    def _print_Rational(self, expr):
+        p, q = int(expr.p), int(expr.q)
+        return "{p}/{q}".format(p=str(p), q=str(q))
+
+    def _print_Relational(self, expr):
+        PREC=precedence(expr)
+        lhs_code = self.parenthesize(expr.lhs, PREC)
+        rhs_code = self.parenthesize(expr.rhs, PREC)
+        op = expr.rel_op
+        if op in spec_relational_ops:
+            op = spec_relational_ops[op]
+        return "{lhs} {rel_op} {rhs}".format(lhs=lhs_code, rel_op=op, rhs=rhs_code)
+
+    def _print_NumberSymbol(self, expr):
+        return number_symbols[expr]
+
+    def _print_NegativeInfinity(self, expr):
+        return '-infinity'
+
+    def _print_Infinity(self, expr):
+        return 'infinity'
+
+    def _print_Idx(self, expr):
+        return self._print(expr.label)
+
+    def _print_BooleanTrue(self, expr):
+        return "true"
+
+    def _print_BooleanFalse(self, expr):
+        return "false"
+
+    def _print_bool(self, expr):
+        return 'true' if expr else 'false'
+
+    def _print_NaN(self, expr):
+        return 'undefined'
+
+    def _get_matrix(self, expr, sparse=False):
+        if S.Zero in expr.shape:
+            _strM = 'Matrix([], storage = {storage})'.format(
+                storage='sparse' if sparse else 'rectangular')
+        else:
+            _strM = 'Matrix({list}, storage = {storage})'.format(
+                list=self._print(expr.tolist()),
+                storage='sparse' if sparse else 'rectangular')
+        return _strM
+
+    def _print_MatrixElement(self, expr):
+        return "{parent}[{i_maple}, {j_maple}]".format(
+            parent=self.parenthesize(expr.parent, PRECEDENCE["Atom"], strict=True),
+            i_maple=self._print(expr.i + 1),
+            j_maple=self._print(expr.j + 1))
+
+    def _print_MatrixBase(self, expr):
+        return self._get_matrix(expr, sparse=False)
+
+    def _print_SparseRepMatrix(self, expr):
+        return self._get_matrix(expr, sparse=True)
+
+    def _print_Identity(self, expr):
+        if isinstance(expr.rows, (Integer, IntegerConstant)):
+            return self._print(sympy.SparseMatrix(expr))
+        else:
+            return "Matrix({var_size}, shape = identity)".format(var_size=self._print(expr.rows))
+
+    def _print_MatMul(self, expr):
+        PREC=precedence(expr)
+        _fact_list = list(expr.args)
+        _const = None
+        if not isinstance(_fact_list[0], (sympy.MatrixBase, sympy.MatrixExpr,
+                                          sympy.MatrixSlice, sympy.MatrixSymbol)):
+            _const, _fact_list = _fact_list[0], _fact_list[1:]
+
+        if _const is None or _const == 1:
+            return '.'.join(self.parenthesize(_m, PREC) for _m in _fact_list)
+        else:
+            return '{c}*{m}'.format(c=_const, m='.'.join(self.parenthesize(_m, PREC) for _m in _fact_list))
+
+    def _print_MatPow(self, expr):
+        # This function requires LinearAlgebra Function in Maple
+        return 'MatrixPower({A}, {n})'.format(A=self._print(expr.base), n=self._print(expr.exp))
+
+    def _print_HadamardProduct(self, expr):
+        PREC = precedence(expr)
+        _fact_list = list(expr.args)
+        return '*'.join(self.parenthesize(_m, PREC) for _m in _fact_list)
+
+    def _print_Derivative(self, expr):
+        _f, (_var, _order) = expr.args
+
+        if _order != 1:
+            _second_arg = '{var}${order}'.format(var=self._print(_var),
+                                                 order=self._print(_order))
+        else:
+            _second_arg = '{var}'.format(var=self._print(_var))
+        return 'diff({func_expr}, {sec_arg})'.format(func_expr=self._print(_f), sec_arg=_second_arg)
+
+
+def maple_code(expr, assign_to=None, **settings):
+    r"""Converts ``expr`` to a string of Maple code.
+
+    Parameters
+    ==========
+
+    expr : Expr
+        A SymPy expression to be converted.
+    assign_to : optional
+        When given, the argument is used as the name of the variable to which
+        the expression is assigned.  Can be a string, ``Symbol``,
+        ``MatrixSymbol``, or ``Indexed`` type.  This can be helpful for
+        expressions that generate multi-line statements.
+    precision : integer, optional
+        The precision for numbers such as pi  [default=16].
+    user_functions : dict, optional
+        A dictionary where keys are ``FunctionClass`` instances and values are
+        their string representations.  Alternatively, the dictionary value can
+        be a list of tuples i.e. [(argument_test, cfunction_string)].  See
+        below for examples.
+    human : bool, optional
+        If True, the result is a single string that may contain some constant
+        declarations for the number symbols.  If False, the same information is
+        returned in a tuple of (symbols_to_declare, not_supported_functions,
+        code_text).  [default=True].
+    contract: bool, optional
+        If True, ``Indexed`` instances are assumed to obey tensor contraction
+        rules and the corresponding nested loops over indices are generated.
+        Setting contract=False will not generate loops, instead the user is
+        responsible to provide values for the indices in the code.
+        [default=True].
+    inline: bool, optional
+        If True, we try to create single-statement code instead of multiple
+        statements.  [default=True].
+
+    """
+    return MapleCodePrinter(settings).doprint(expr, assign_to)
+
+
+def print_maple_code(expr, **settings):
+    """Prints the Maple representation of the given expression.
+
+    See :func:`maple_code` for the meaning of the optional arguments.
+
+    Examples
+    ========
+
+    >>> from sympy import print_maple_code, symbols
+    >>> x, y = symbols('x y')
+    >>> print_maple_code(x, assign_to=y)
+    y := x
+    """
+    print(maple_code(expr, **settings))

venv/lib/python3.10/site-packages/sympy/printing/mathml.py

@@ -0,0 +1,2126 @@
+"""
+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": '·',
+    }
+
+    def __init__(self, settings=None):
+        Printer.__init__(self, settings)
+        from xml.dom.minidom import Document, Text
+
+        self.dom = Document()
+
+        # Workaround to allow strings to remain unescaped
+        # Based on
+        # https://stackoverflow.com/questions/38015864/python-xml-dom-minidom-\
+        #                              please-dont-escape-my-strings/38041194
+        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 apply_patch(self):
+        # Applying the patch of xml.dom.minidom bug
+        # Date: 2011-11-18
+        # Description: http://ronrothman.com/public/leftbraned/xml-dom-minidom\
+        #                   -toprettyxml-and-silly-whitespace/#best-solution
+        # Issue: https://bugs.python.org/issue4147
+        # Patch: https://hg.python.org/cpython/rev/7262f8f276ff/
+
+        from xml.dom.minidom import Element, Text, Node, _write_data
+
+        def writexml(self, writer, indent="", addindent="", newl=""):
+            # indent = current indentation
+            # addindent = indentation to add to higher levels
+            # newl = newline string
+            writer.write(indent + "<" + self.tagName)
+
+            attrs = self._get_attributes()
+            a_names = list(attrs.keys())
+            a_names.sort()
+
+            for a_name in a_names:
+                writer.write(" %s=\"" % a_name)
+                _write_data(writer, attrs[a_name].value)
+                writer.write("\"")
+            if self.childNodes:
+                writer.write(">")
+                if (len(self.childNodes) == 1 and
+                        self.childNodes[0].nodeType == Node.TEXT_NODE):
+                    self.childNodes[0].writexml(writer, '', '', '')
+                else:
+                    writer.write(newl)
+                    for node in self.childNodes:
+                        node.writexml(
+                            writer, indent + addindent, addindent, newl)
+                    writer.write(indent)
+                writer.write("</%s>%s" % (self.tagName, newl))
+            else:
+                writer.write("/>%s" % (newl))
+        self._Element_writexml_old = Element.writexml
+        Element.writexml = writexml
+
+        def writexml(self, writer, indent="", addindent="", newl=""):
+            _write_data(writer, "%s%s%s" % (indent, self.data, newl))
+        self._Text_writexml_old = Text.writexml
+        Text.writexml = writexml
+
+    def restore_patch(self):
+        from xml.dom.minidom import Element, Text
+        Element.writexml = self._Element_writexml_old
+        Text.writexml = self._Text_writexml_old
+
+
+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]
+        # Not found in the MRO set
+        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:
+            # 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 _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():
+                # use minus
+                x = self.dom.createElement('apply')
+                x.appendChild(self.dom.createElement('minus'))
+                x.appendChild(lastProcessed)
+                x.appendChild(self._print(-arg))
+                # invert expression since this is now minused
+                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:
+            # We need the last conditional to be a True, otherwise the resulting
+            # function may not return a result.
+            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:
+            # don't divide
+            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'))
+        # numerator
+        xnum = self.dom.createElement('cn')
+        xnum.appendChild(self.dom.createTextNode(str(e.p)))
+        # denominator
+        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):
+        # Printer can be shared because Sum and Integral have the
+        # same internal representation.
+        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
+
+        # translate name, supers and subs to unicode characters
+        def translate(s):
+            if s in greek_unicode:
+                return greek_unicode.get(s)
+            else:
+                return s
+
+        name, supers, subs = 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):
+        # Here we use root instead of power if the exponent is the reciprocal
+        # of an integer
+        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
+
+    # XXX Symmetric difference is not supported for MathML content printers.
+
+
+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': '&#x2192;',
+            'Derivative': '&dd;',
+            'int': 'mn',
+            'Symbol': 'mi',
+            'Integral': '&int;',
+            'Sum': '&#x2211;',
+            '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': '&#x2260;',
+            'GreaterThan': '&#x2265;',
+            'LessThan': '&#x2264;',
+            'StrictGreaterThan': '>',
+            'StrictLessThan': '<',
+            'lerchphi': '&#x3A6;',
+            'zeta': '&#x3B6;',
+            'dirichlet_eta': '&#x3B7;',
+            'elliptic_k': '&#x39A;',
+            'lowergamma': '&#x3B3;',
+            'uppergamma': '&#x393;',
+            'gamma': '&#x393;',
+            'totient': '&#x3D5;',
+            'reduced_totient': '&#x3BB;',
+            'primenu': '&#x3BD;',
+            'primeomega': '&#x3A9;',
+            'fresnels': 'S',
+            'fresnelc': 'C',
+            'LambertW': 'W',
+            'Heaviside': '&#x398;',
+            'BooleanTrue': 'True',
+            'BooleanFalse': 'False',
+            'NoneType': 'None',
+            'mathieus': 'S',
+            'mathieuc': 'C',
+            'mathieusprime': 'S&#x2032;',
+            'mathieucprime': 'C&#x2032;',
+        }
+
+        def mul_symbol_selection():
+            if (self._settings["mul_symbol"] is None or
+                    self._settings["mul_symbol"] == 'None'):
+                return '&InvisibleTimes;'
+            elif self._settings["mul_symbol"] == 'times':
+                return '&#xD7;'
+            elif self._settings["mul_symbol"] == 'dot':
+                return '&#xB7;'
+            elif self._settings["mul_symbol"] == 'ldot':
+                return '&#x2024;'
+            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]
+        # Not found in the MRO set
+        if e.__class__.__name__ == "Mul":
+            return mul_symbol_selection()
+        n = e.__class__.__name__
+        return n.lower()
+
+    def parenthesize(self, item, level, strict=False):
+        prec_val = precedence_traditional(item)
+        if (prec_val < level) or ((not strict) and prec_val <= level):
+            brac = self.dom.createElement('mfenced')
+            brac.appendChild(self._print(item))
+            return brac
+        else:
+            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():
+                # use minus
+                x = self.dom.createElement('mo')
+                x.appendChild(self.dom.createTextNode('-'))
+                y = self._print(-arg)
+                # invert expression since this is now minused
+            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)
+        if self._settings["mat_delim"] == '':
+            return table
+        brac = self.dom.createElement('mfenced')
+        if self._settings["mat_delim"] == "[":
+            brac.setAttribute('close', ']')
+            brac.setAttribute('open', '[')
+        brac.appendChild(table)
+        return brac
+
+    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:
+            # don't divide
+            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('&ImaginaryI;'))
+        return x
+
+    def _print_GoldenRatio(self, e):
+        x = self.dom.createElement('mi')
+        x.appendChild(self.dom.createTextNode('&#x3A6;'))
+        return x
+
+    def _print_Exp1(self, e):
+        x = self.dom.createElement('mi')
+        x.appendChild(self.dom.createTextNode('&ExponentialE;'))
+        return x
+
+    def _print_Pi(self, e):
+        x = self.dom.createElement('mi')
+        x.appendChild(self.dom.createTextNode('&pi;'))
+        return x
+
+    def _print_Infinity(self, e):
+        x = self.dom.createElement('mi')
+        x.appendChild(self.dom.createTextNode('&#x221E;'))
+        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('&#x210F;'))
+        return x
+
+    def _print_EulerGamma(self, e):
+        x = self.dom.createElement('mi')
+        x.appendChild(self.dom.createTextNode('&#x3B3;'))
+        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('&#x2020;'))
+        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('&#x2208;'))
+        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('&#x210B;'))
+        return x
+
+    def _print_ComplexSpace(self, e):
+        msup = self.dom.createElement('msup')
+        msup.appendChild(self.dom.createTextNode('&#x1D49E;'))
+        msup.appendChild(self._print(e.args[0]))
+        return msup
+
+    def _print_FockSpace(self, e):
+        x = self.dom.createElement('mi')
+        x.appendChild(self.dom.createTextNode('&#x2131;'))
+        return x
+
+
+    def _print_Integral(self, expr):
+        intsymbols = {1: "&#x222B;", 2: "&#x222C;", 3: "&#x222D;"}
+
+        mrow = self.dom.createElement('mrow')
+        if len(expr.limits) <= 3 and all(len(lim) == 1 for lim in expr.limits):
+            # Only up to three-integral signs exists
+            mo = self.dom.createElement('mo')
+            mo.appendChild(self.dom.createTextNode(intsymbols[len(expr.limits)]))
+            mrow.appendChild(mo)
+        else:
+            # Either more than three or limits provided
+            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)
+        # print function
+        mrow.appendChild(self.parenthesize(expr.function, PRECEDENCE["Mul"],
+                                           strict=True))
+        # print integration variables
+        for lim in reversed(expr.limits):
+            d = self.dom.createElement('mo')
+            d.appendChild(self.dom.createTextNode('&dd;'))
+            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)
+        if len(str(e.function)) == 1:
+            mrow.appendChild(self._print(e.function))
+        else:
+            fence = self.dom.createElement('mfenced')
+            fence.appendChild(self._print(e.function))
+            mrow.appendChild(fence)
+
+        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
+
+        # translate name, supers and subs to unicode characters
+        def translate(s):
+            if s in greek_unicode:
+                return greek_unicode.get(s)
+            else:
+                return s
+
+        name, supers, subs = 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))
+        # Set bold font?
+        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):
+        brac = self.dom.createElement('mfenced')
+        frac = self.dom.createElement('mfrac')
+        frac.setAttribute('linethickness', '0')
+        frac.appendChild(self._print(expr.args[0]))
+        frac.appendChild(self._print(expr.args[1]))
+        brac.appendChild(frac)
+        return brac
+
+    def _print_Pow(self, e):
+        # Here we use root instead of power if the exponent is the
+        # reciprocal of an integer
+        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):
+        brac = self.dom.createElement('mfenced')
+        brac.setAttribute('close', '\u27e9')
+        brac.setAttribute('open', '\u27e8')
+        brac.appendChild(self._print(i.min))
+        brac.appendChild(self._print(i.max))
+        return brac
+
+    def _print_Derivative(self, e):
+
+        if requires_partial(e.expr):
+            d = '&#x2202;'
+        else:
+            d = self.mathml_tag(e)
+
+        # Determine denominator
+        m = self.dom.createElement('mrow')
+        dim = 0  # Total diff dimension, for numerator
+        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)
+
+        # Print function
+        mrow.appendChild(self._print(e.expr))
+
+        return mrow
+
+    def _print_Function(self, e):
+        mrow = self.dom.createElement('mrow')
+        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)))
+        y = self.dom.createElement('mfenced')
+        for arg in e.args:
+            y.appendChild(self._print(arg))
+        mrow.appendChild(x)
+        mrow.appendChild(y)
+        return mrow
+
+    def _print_Float(self, expr):
+        # Based off of that in StrPrinter
+        dps = prec_to_dps(expr._prec)
+        str_real = mlib_to_str(expr._mpf_, dps, strip_zeros=True)
+
+        # Must always have a mul symbol (as 2.5 10^{20} just looks odd)
+        # thus we use the number separator
+        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('mfenced')
+        brac.appendChild(self._print(expr.args[1]))
+        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)
+        brac = self.dom.createElement('mfenced')
+        for arg in e.args:
+            brac.appendChild(self._print(arg))
+        mrow.appendChild(brac)
+        return mrow
+
+    def _print_Tuple(self, e):
+        mrow = self.dom.createElement('mrow')
+        x = self.dom.createElement('mfenced')
+        for arg in e.args:
+            x.appendChild(self._print(arg))
+        mrow.appendChild(x)
+        return mrow
+
+    def _print_Interval(self, i):
+        mrow = self.dom.createElement('mrow')
+        brac = self.dom.createElement('mfenced')
+        if i.start == i.end:
+            # Most often, this type of Interval is converted to a FiniteSet
+            brac.setAttribute('close', '}')
+            brac.setAttribute('open', '{')
+            brac.appendChild(self._print(i.start))
+        else:
+            if i.right_open:
+                brac.setAttribute('close', ')')
+            else:
+                brac.setAttribute('close', ']')
+
+            if i.left_open:
+                brac.setAttribute('open', '(')
+            else:
+                brac.setAttribute('open', '[')
+            brac.appendChild(self._print(i.start))
+            brac.appendChild(self._print(i.end))
+
+        mrow.appendChild(brac)
+        return mrow
+
+    def _print_Abs(self, expr, exp=None):
+        mrow = self.dom.createElement('mrow')
+        x = self.dom.createElement('mfenced')
+        x.setAttribute('close', '|')
+        x.setAttribute('open', '|')
+        x.appendChild(self._print(expr.args[0]))
+        mrow.appendChild(x)
+        return mrow
+
+    _print_Determinant = _print_Abs
+
+    def _print_re_im(self, c, expr):
+        mrow = self.dom.createElement('mrow')
+        mi = self.dom.createElement('mi')
+        mi.setAttribute('mathvariant', 'fraktur')
+        mi.appendChild(self.dom.createTextNode(c))
+        mrow.appendChild(mi)
+        brac = self.dom.createElement('mfenced')
+        brac.appendChild(self._print(expr))
+        mrow.appendChild(brac)
+        return mrow
+
+    def _print_re(self, expr, exp=None):
+        return self._print_re_im('R', expr.args[0])
+
+    def _print_im(self, expr, exp=None):
+        return self._print_re_im('I', 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, '&#x222A;', prec)
+
+    def _print_Intersection(self, expr):
+        prec = PRECEDENCE_TRADITIONAL['Intersection']
+        return self._print_SetOp(expr, '&#x2229;', prec)
+
+    def _print_Complement(self, expr):
+        prec = PRECEDENCE_TRADITIONAL['Complement']
+        return self._print_SetOp(expr, '&#x2216;', prec)
+
+    def _print_SymmetricDifference(self, expr):
+        prec = PRECEDENCE_TRADITIONAL['SymmetricDifference']
+        return self._print_SetOp(expr, '&#x2206;', prec)
+
+    def _print_ProductSet(self, expr):
+        prec = PRECEDENCE_TRADITIONAL['ProductSet']
+        return self._print_SetOp(expr, '&#x00d7;', 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('mfenced')
+        brac.setAttribute('close', '}')
+        brac.setAttribute('open', '{')
+        for item in items:
+            brac.appendChild(self._print(item))
+        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('mfenced')
+            brac.appendChild(self._print(args[0]))
+            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('mfenced')
+                y.appendChild(self._print(arg))
+            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:
+            # Not clear if this is ever called
+            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: # No + for first item
+                        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: # No + for first item
+                        mo = self.dom.createElement('mo')
+                        mo.appendChild(self.dom.createTextNode('+'))
+                        mrow.appendChild(mo)
+                    mbrac = self.dom.createElement('mfenced')
+                    mbrac.appendChild(self._print(v))
+                    mrow.appendChild(mbrac)
+                    mo = self.dom.createElement('mo')
+                    mo.appendChild(self.dom.createTextNode('&InvisibleTimes;'))
+                    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, '&#x2227;')
+
+    def _print_Or(self, expr):
+        args = sorted(expr.args, key=default_sort_key)
+        return self._print_LogOp(args, '&#x2228;')
+
+    def _print_Xor(self, expr):
+        args = sorted(expr.args, key=default_sort_key)
+        return self._print_LogOp(args, '&#x22BB;')
+
+    def _print_Implies(self, expr):
+        return self._print_LogOp(expr.args, '&#x21D2;')
+
+    def _print_Equivalent(self, expr):
+        args = sorted(expr.args, key=default_sort_key)
+        return self._print_LogOp(args, '&#x21D4;')
+
+    def _print_Not(self, e):
+        mrow = self.dom.createElement('mrow')
+        mo = self.dom.createElement('mo')
+        mo.appendChild(self.dom.createTextNode('&#xAC;'))
+        mrow.appendChild(mo)
+        if (e.args[0].is_Boolean):
+            x = self.dom.createElement('mfenced')
+            x.appendChild(self._print(e.args[0]))
+        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"
+        brac = self.dom.createElement('mfenced')
+        brac.setAttribute('close', '}')
+        brac.setAttribute('open', '{')
+
+        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)
+
+        for el in printset:
+            if el == dots:
+                mi = self.dom.createElement('mi')
+                mi.appendChild(self.dom.createTextNode(dots))
+                brac.appendChild(mi)
+            else:
+                brac.appendChild(self._print(el))
+
+        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)
+        brac = self.dom.createElement('mfenced')
+        for symbol in args:
+            brac.appendChild(self._print(symbol))
+        mrow.appendChild(brac)
+        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('&#xD7;'))
+        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('&#x2207;'))
+        mrow.appendChild(mo)
+        mo = self.dom.createElement('mo')
+        mo.appendChild(self.dom.createTextNode('&#xD7;'))
+        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('&#x2207;'))
+        mrow.appendChild(mo)
+        mo = self.dom.createElement('mo')
+        mo.appendChild(self.dom.createTextNode('&#xB7;'))
+        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('&#xB7;'))
+        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('&#x2207;'))
+        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('&#x2206;'))
+        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('&#x2124;'))
+        return x
+
+    def _print_Complexes(self, e):
+        x = self.dom.createElement('mi')
+        x.setAttribute('mathvariant', 'normal')
+        x.appendChild(self.dom.createTextNode('&#x2102;'))
+        return x
+
+    def _print_Reals(self, e):
+        x = self.dom.createElement('mi')
+        x.setAttribute('mathvariant', 'normal')
+        x.appendChild(self.dom.createTextNode('&#x211D;'))
+        return x
+
+    def _print_Naturals(self, e):
+        x = self.dom.createElement('mi')
+        x.setAttribute('mathvariant', 'normal')
+        x.appendChild(self.dom.createTextNode('&#x2115;'))
+        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('&#x2115;'))
+        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]
+        sup = self.dom.createElement('msup')
+        brac = self.dom.createElement('mfenced')
+        brac.setAttribute('close', '\u27e9')
+        brac.setAttribute('open', '\u27e8')
+        brac.appendChild(self._print(shift))
+        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):
+        # Print name_arg[0] for one argument or name_arg[0](arg[1])
+        # for more than one argument
+        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
+        # TODO: copy-pasted from _print_Function: can we do better?
+        mrow = self.dom.createElement('mrow')
+        y = self.dom.createElement('mfenced')
+        for arg in e.args[1:]:
+            y.appendChild(self._print(arg))
+        mrow.appendChild(sub)
+        mrow.appendChild(y)
+        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, '&#x03B3;')
+
+    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('&#x221E;'))
+        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('&#x2205;'))
+        return x
+
+    def _print_UniversalSet(self, e):
+        x = self.dom.createElement('mo')
+        x.appendChild(self.dom.createTextNode('&#x1D54C;'))
+        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('mfenced')
+            brac.appendChild(self._print(mat))
+            sup.appendChild(brac)
+        else:
+            sup.appendChild(self._print(mat))
+        mo = self.dom.createElement('mo')
+        mo.appendChild(self.dom.createTextNode('&#x2020;'))
+        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('mfenced')
+            brac.appendChild(self._print(mat))
+            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('mfenced')
+            brac.appendChild(self._print(mat))
+            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('&InvisibleTimes;'))
+            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('mfenced')
+            brac.appendChild(self._print(base))
+            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('&#x2218;'))
+            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('&#x1D7D8'))
+        return x
+
+    def _print_OneMatrix(self, Z):
+        x = self.dom.createElement('mn')
+        x.appendChild(self.dom.createTextNode('&#x1D7D9'))
+        return x
+
+    def _print_Identity(self, I):
+        x = self.dom.createElement('mi')
+        x.appendChild(self.dom.createTextNode('&#x1D540;'))
+        return x
+
+    def _print_floor(self, e):
+        mrow = self.dom.createElement('mrow')
+        x = self.dom.createElement('mfenced')
+        x.setAttribute('close', '\u230B')
+        x.setAttribute('open', '\u230A')
+        x.appendChild(self._print(e.args[0]))
+        mrow.appendChild(x)
+        return mrow
+
+    def _print_ceiling(self, e):
+        mrow = self.dom.createElement('mrow')
+        x = self.dom.createElement('mfenced')
+        x.setAttribute('close', '\u2309')
+        x.setAttribute('open', '\u2308')
+        x.appendChild(self._print(e.args[0]))
+        mrow.appendChild(x)
+        return mrow
+
+    def _print_Lambda(self, e):
+        x = self.dom.createElement('mfenced')
+        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(symbols)
+        mo = self.dom.createElement('mo')
+        mo.appendChild(self.dom.createTextNode('&#x21A6;'))
+        mrow.appendChild(mo)
+        mrow.appendChild(self._print(e.args[1]))
+        x.appendChild(mrow)
+        return x
+
+    def _print_tuple(self, e):
+        x = self.dom.createElement('mfenced')
+        for i in e:
+            x.appendChild(self._print(i))
+        return x
+
+    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('mfenced')
+        brac.setAttribute("close", "")
+        brac.setAttribute("open", "")
+        for i in e.indices:
+            brac.appendChild(self._print(i))
+        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('&#x1d5a5;'))
+        x.appendChild(mi)
+        y = self.dom.createElement('mfenced')
+        y.setAttribute("separators", "|")
+        for i in e.args:
+            y.appendChild(self._print(i))
+        x.appendChild(y)
+        return x
+
+    def _print_elliptic_e(self, e):
+        x = self.dom.createElement('mrow')
+        mi = self.dom.createElement('mi')
+        mi.appendChild(self.dom.createTextNode('&#x1d5a4;'))
+        x.appendChild(mi)
+        y = self.dom.createElement('mfenced')
+        y.setAttribute("separators", "|")
+        for i in e.args:
+            y.appendChild(self._print(i))
+        x.appendChild(y)
+        return x
+
+    def _print_elliptic_pi(self, e):
+        x = self.dom.createElement('mrow')
+        mi = self.dom.createElement('mi')
+        mi.appendChild(self.dom.createTextNode('&#x1d6f1;'))
+        x.appendChild(mi)
+        y = self.dom.createElement('mfenced')
+        if len(e.args) == 2:
+            y.setAttribute("separators", "|")
+        else:
+            y.setAttribute("separators", ";|")
+        for i in e.args:
+            y.appendChild(self._print(i))
+        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))
+    s.apply_patch()
+    pretty_xml = xml.toprettyxml()
+    s.restore_patch()
+
+    print(pretty_xml)
+
+
+# For backward compatibility
+MathMLPrinter = MathMLContentPrinter

venv/lib/python3.10/site-packages/sympy/printing/numpy.py

@@ -0,0 +1,507 @@
+from sympy.core import S
+from sympy.core.function import Lambda
+from sympy.core.power import Pow
+from .pycode import PythonCodePrinter, _known_functions_math, _print_known_const, _print_known_func, _unpack_integral_limits, ArrayPrinter
+from .codeprinter import CodePrinter
+
+
+_not_in_numpy = 'erf erfc factorial gamma loggamma'.split()
+_in_numpy = [(k, v) for k, v in _known_functions_math.items() if k not in _not_in_numpy]
+_known_functions_numpy = dict(_in_numpy, **{
+    'acos': 'arccos',
+    'acosh': 'arccosh',
+    'asin': 'arcsin',
+    'asinh': 'arcsinh',
+    'atan': 'arctan',
+    'atan2': 'arctan2',
+    'atanh': 'arctanh',
+    'exp2': 'exp2',
+    'sign': 'sign',
+    'logaddexp': 'logaddexp',
+    'logaddexp2': 'logaddexp2',
+})
+_known_constants_numpy = {
+    'Exp1': 'e',
+    'Pi': 'pi',
+    'EulerGamma': 'euler_gamma',
+    'NaN': 'nan',
+    'Infinity': 'PINF',
+    'NegativeInfinity': 'NINF'
+}
+
+_numpy_known_functions = {k: 'numpy.' + v for k, v in _known_functions_numpy.items()}
+_numpy_known_constants = {k: 'numpy.' + v for k, v in _known_constants_numpy.items()}
+
+class NumPyPrinter(ArrayPrinter, PythonCodePrinter):
+    """
+    Numpy printer which handles vectorized piecewise functions,
+    logical operators, etc.
+    """
+
+    _module = 'numpy'
+    _kf = _numpy_known_functions
+    _kc = _numpy_known_constants
+
+    def __init__(self, settings=None):
+        """
+        `settings` is passed to CodePrinter.__init__()
+        `module` specifies the array module to use, currently 'NumPy', 'CuPy'
+        or 'JAX'.
+        """
+        self.language = "Python with {}".format(self._module)
+        self.printmethod = "_{}code".format(self._module)
+
+        self._kf = {**PythonCodePrinter._kf, **self._kf}
+
+        super().__init__(settings=settings)
+
+
+    def _print_seq(self, seq):
+        "General sequence printer: converts to tuple"
+        # Print tuples here instead of lists because numba supports
+        #     tuples in nopython mode.
+        delimiter=', '
+        return '({},)'.format(delimiter.join(self._print(item) for item in seq))
+
+    def _print_MatMul(self, expr):
+        "Matrix multiplication printer"
+        if expr.as_coeff_matrices()[0] is not S.One:
+            expr_list = expr.as_coeff_matrices()[1]+[(expr.as_coeff_matrices()[0])]
+            return '({})'.format(').dot('.join(self._print(i) for i in expr_list))
+        return '({})'.format(').dot('.join(self._print(i) for i in expr.args))
+
+    def _print_MatPow(self, expr):
+        "Matrix power printer"
+        return '{}({}, {})'.format(self._module_format(self._module + '.linalg.matrix_power'),
+            self._print(expr.args[0]), self._print(expr.args[1]))
+
+    def _print_Inverse(self, expr):
+        "Matrix inverse printer"
+        return '{}({})'.format(self._module_format(self._module + '.linalg.inv'),
+            self._print(expr.args[0]))
+
+    def _print_DotProduct(self, expr):
+        # DotProduct allows any shape order, but numpy.dot does matrix
+        # multiplication, so we have to make sure it gets 1 x n by n x 1.
+        arg1, arg2 = expr.args
+        if arg1.shape[0] != 1:
+            arg1 = arg1.T
+        if arg2.shape[1] != 1:
+            arg2 = arg2.T
+
+        return "%s(%s, %s)" % (self._module_format(self._module + '.dot'),
+                               self._print(arg1),
+                               self._print(arg2))
+
+    def _print_MatrixSolve(self, expr):
+        return "%s(%s, %s)" % (self._module_format(self._module + '.linalg.solve'),
+                               self._print(expr.matrix),
+                               self._print(expr.vector))
+
+    def _print_ZeroMatrix(self, expr):
+        return '{}({})'.format(self._module_format(self._module + '.zeros'),
+            self._print(expr.shape))
+
+    def _print_OneMatrix(self, expr):
+        return '{}({})'.format(self._module_format(self._module + '.ones'),
+            self._print(expr.shape))
+
+    def _print_FunctionMatrix(self, expr):
+        from sympy.abc import i, j
+        lamda = expr.lamda
+        if not isinstance(lamda, Lambda):
+            lamda = Lambda((i, j), lamda(i, j))
+        return '{}(lambda {}: {}, {})'.format(self._module_format(self._module + '.fromfunction'),
+            ', '.join(self._print(arg) for arg in lamda.args[0]),
+            self._print(lamda.args[1]), self._print(expr.shape))
+
+    def _print_HadamardProduct(self, expr):
+        func = self._module_format(self._module + '.multiply')
+        return ''.join('{}({}, '.format(func, self._print(arg)) \
+            for arg in expr.args[:-1]) + "{}{}".format(self._print(expr.args[-1]),
+            ')' * (len(expr.args) - 1))
+
+    def _print_KroneckerProduct(self, expr):
+        func = self._module_format(self._module + '.kron')
+        return ''.join('{}({}, '.format(func, self._print(arg)) \
+            for arg in expr.args[:-1]) + "{}{}".format(self._print(expr.args[-1]),
+            ')' * (len(expr.args) - 1))
+
+    def _print_Adjoint(self, expr):
+        return '{}({}({}))'.format(
+            self._module_format(self._module + '.conjugate'),
+            self._module_format(self._module + '.transpose'),
+            self._print(expr.args[0]))
+
+    def _print_DiagonalOf(self, expr):
+        vect = '{}({})'.format(
+            self._module_format(self._module + '.diag'),
+            self._print(expr.arg))
+        return '{}({}, (-1, 1))'.format(
+            self._module_format(self._module + '.reshape'), vect)
+
+    def _print_DiagMatrix(self, expr):
+        return '{}({})'.format(self._module_format(self._module + '.diagflat'),
+            self._print(expr.args[0]))
+
+    def _print_DiagonalMatrix(self, expr):
+        return '{}({}, {}({}, {}))'.format(self._module_format(self._module + '.multiply'),
+            self._print(expr.arg), self._module_format(self._module + '.eye'),
+            self._print(expr.shape[0]), self._print(expr.shape[1]))
+
+    def _print_Piecewise(self, expr):
+        "Piecewise function printer"
+        from sympy.logic.boolalg import ITE, simplify_logic
+        def print_cond(cond):
+            """ Problem having an ITE in the cond. """
+            if cond.has(ITE):
+                return self._print(simplify_logic(cond))
+            else:
+                return self._print(cond)
+        exprs = '[{}]'.format(','.join(self._print(arg.expr) for arg in expr.args))
+        conds = '[{}]'.format(','.join(print_cond(arg.cond) for arg in expr.args))
+        # If [default_value, True] is a (expr, cond) sequence in a Piecewise object
+        #     it will behave the same as passing the 'default' kwarg to select()
+        #     *as long as* it is the last element in expr.args.
+        # If this is not the case, it may be triggered prematurely.
+        return '{}({}, {}, default={})'.format(
+            self._module_format(self._module + '.select'), conds, exprs,
+            self._print(S.NaN))
+
+    def _print_Relational(self, expr):
+        "Relational printer for Equality and Unequality"
+        op = {
+            '==' :'equal',
+            '!=' :'not_equal',
+            '<'  :'less',
+            '<=' :'less_equal',
+            '>'  :'greater',
+            '>=' :'greater_equal',
+        }
+        if expr.rel_op in op:
+            lhs = self._print(expr.lhs)
+            rhs = self._print(expr.rhs)
+            return '{op}({lhs}, {rhs})'.format(op=self._module_format(self._module + '.'+op[expr.rel_op]),
+                                               lhs=lhs, rhs=rhs)
+        return super()._print_Relational(expr)
+
+    def _print_And(self, expr):
+        "Logical And printer"
+        # We have to override LambdaPrinter because it uses Python 'and' keyword.
+        # If LambdaPrinter didn't define it, we could use StrPrinter's
+        # version of the function and add 'logical_and' to NUMPY_TRANSLATIONS.
+        return '{}.reduce(({}))'.format(self._module_format(self._module + '.logical_and'), ','.join(self._print(i) for i in expr.args))
+
+    def _print_Or(self, expr):
+        "Logical Or printer"
+        # We have to override LambdaPrinter because it uses Python 'or' keyword.
+        # If LambdaPrinter didn't define it, we could use StrPrinter's
+        # version of the function and add 'logical_or' to NUMPY_TRANSLATIONS.
+        return '{}.reduce(({}))'.format(self._module_format(self._module + '.logical_or'), ','.join(self._print(i) for i in expr.args))
+
+    def _print_Not(self, expr):
+        "Logical Not printer"
+        # We have to override LambdaPrinter because it uses Python 'not' keyword.
+        # If LambdaPrinter didn't define it, we would still have to define our
+        #     own because StrPrinter doesn't define it.
+        return '{}({})'.format(self._module_format(self._module + '.logical_not'), ','.join(self._print(i) for i in expr.args))
+
+    def _print_Pow(self, expr, rational=False):
+        # XXX Workaround for negative integer power error
+        if expr.exp.is_integer and expr.exp.is_negative:
+            expr = Pow(expr.base, expr.exp.evalf(), evaluate=False)
+        return self._hprint_Pow(expr, rational=rational, sqrt=self._module + '.sqrt')
+
+    def _print_Min(self, expr):
+        return '{}(({}), axis=0)'.format(self._module_format(self._module + '.amin'), ','.join(self._print(i) for i in expr.args))
+
+    def _print_Max(self, expr):
+        return '{}(({}), axis=0)'.format(self._module_format(self._module + '.amax'), ','.join(self._print(i) for i in expr.args))
+
+    def _print_arg(self, expr):
+        return "%s(%s)" % (self._module_format(self._module + '.angle'), self._print(expr.args[0]))
+
+    def _print_im(self, expr):
+        return "%s(%s)" % (self._module_format(self._module + '.imag'), self._print(expr.args[0]))
+
+    def _print_Mod(self, expr):
+        return "%s(%s)" % (self._module_format(self._module + '.mod'), ', '.join(
+            (self._print(arg) for arg in expr.args)))
+
+    def _print_re(self, expr):
+        return "%s(%s)" % (self._module_format(self._module + '.real'), self._print(expr.args[0]))
+
+    def _print_sinc(self, expr):
+        return "%s(%s)" % (self._module_format(self._module + '.sinc'), self._print(expr.args[0]/S.Pi))
+
+    def _print_MatrixBase(self, expr):
+        func = self.known_functions.get(expr.__class__.__name__, None)
+        if func is None:
+            func = self._module_format(self._module + '.array')
+        return "%s(%s)" % (func, self._print(expr.tolist()))
+
+    def _print_Identity(self, expr):
+        shape = expr.shape
+        if all(dim.is_Integer for dim in shape):
+            return "%s(%s)" % (self._module_format(self._module + '.eye'), self._print(expr.shape[0]))
+        else:
+            raise NotImplementedError("Symbolic matrix dimensions are not yet supported for identity matrices")
+
+    def _print_BlockMatrix(self, expr):
+        return '{}({})'.format(self._module_format(self._module + '.block'),
+                                 self._print(expr.args[0].tolist()))
+
+    def _print_NDimArray(self, expr):
+        if len(expr.shape) == 1:
+            return self._module + '.array(' + self._print(expr.args[0]) + ')'
+        if len(expr.shape) == 2:
+            return self._print(expr.tomatrix())
+        # Should be possible to extend to more dimensions
+        return CodePrinter._print_not_supported(self, expr)
+
+    _add = "add"
+    _einsum = "einsum"
+    _transpose = "transpose"
+    _ones = "ones"
+    _zeros = "zeros"
+
+    _print_lowergamma = CodePrinter._print_not_supported
+    _print_uppergamma = CodePrinter._print_not_supported
+    _print_fresnelc = CodePrinter._print_not_supported
+    _print_fresnels = CodePrinter._print_not_supported
+
+for func in _numpy_known_functions:
+    setattr(NumPyPrinter, f'_print_{func}', _print_known_func)
+
+for const in _numpy_known_constants:
+    setattr(NumPyPrinter, f'_print_{const}', _print_known_const)
+
+
+_known_functions_scipy_special = {
+    'Ei': 'expi',
+    'erf': 'erf',
+    'erfc': 'erfc',
+    'besselj': 'jv',
+    'bessely': 'yv',
+    'besseli': 'iv',
+    'besselk': 'kv',
+    'cosm1': 'cosm1',
+    'powm1': 'powm1',
+    'factorial': 'factorial',
+    'gamma': 'gamma',
+    'loggamma': 'gammaln',
+    'digamma': 'psi',
+    'polygamma': 'polygamma',
+    'RisingFactorial': 'poch',
+    'jacobi': 'eval_jacobi',
+    'gegenbauer': 'eval_gegenbauer',
+    'chebyshevt': 'eval_chebyt',
+    'chebyshevu': 'eval_chebyu',
+    'legendre': 'eval_legendre',
+    'hermite': 'eval_hermite',
+    'laguerre': 'eval_laguerre',
+    'assoc_laguerre': 'eval_genlaguerre',
+    'beta': 'beta',
+    'LambertW' : 'lambertw',
+}
+
+_known_constants_scipy_constants = {
+    'GoldenRatio': 'golden_ratio',
+    'Pi': 'pi',
+}
+_scipy_known_functions = {k : "scipy.special." + v for k, v in _known_functions_scipy_special.items()}
+_scipy_known_constants = {k : "scipy.constants." + v for k, v in _known_constants_scipy_constants.items()}
+
+class SciPyPrinter(NumPyPrinter):
+
+    _kf = {**NumPyPrinter._kf, **_scipy_known_functions}
+    _kc = {**NumPyPrinter._kc, **_scipy_known_constants}
+
+    def __init__(self, settings=None):
+        super().__init__(settings=settings)
+        self.language = "Python with SciPy and NumPy"
+
+    def _print_SparseRepMatrix(self, expr):
+        i, j, data = [], [], []
+        for (r, c), v in expr.todok().items():
+            i.append(r)
+            j.append(c)
+            data.append(v)
+
+        return "{name}(({data}, ({i}, {j})), shape={shape})".format(
+            name=self._module_format('scipy.sparse.coo_matrix'),
+            data=data, i=i, j=j, shape=expr.shape
+        )
+
+    _print_ImmutableSparseMatrix = _print_SparseRepMatrix
+
+    # SciPy's lpmv has a different order of arguments from assoc_legendre
+    def _print_assoc_legendre(self, expr):
+        return "{0}({2}, {1}, {3})".format(
+            self._module_format('scipy.special.lpmv'),
+            self._print(expr.args[0]),
+            self._print(expr.args[1]),
+            self._print(expr.args[2]))
+
+    def _print_lowergamma(self, expr):
+        return "{0}({2})*{1}({2}, {3})".format(
+            self._module_format('scipy.special.gamma'),
+            self._module_format('scipy.special.gammainc'),
+            self._print(expr.args[0]),
+            self._print(expr.args[1]))
+
+    def _print_uppergamma(self, expr):
+        return "{0}({2})*{1}({2}, {3})".format(
+            self._module_format('scipy.special.gamma'),
+            self._module_format('scipy.special.gammaincc'),
+            self._print(expr.args[0]),
+            self._print(expr.args[1]))
+
+    def _print_betainc(self, expr):
+        betainc = self._module_format('scipy.special.betainc')
+        beta = self._module_format('scipy.special.beta')
+        args = [self._print(arg) for arg in expr.args]
+        return f"({betainc}({args[0]}, {args[1]}, {args[3]}) - {betainc}({args[0]}, {args[1]}, {args[2]})) \
+            * {beta}({args[0]}, {args[1]})"
+
+    def _print_betainc_regularized(self, expr):
+        return "{0}({1}, {2}, {4}) - {0}({1}, {2}, {3})".format(
+            self._module_format('scipy.special.betainc'),
+            self._print(expr.args[0]),
+            self._print(expr.args[1]),
+            self._print(expr.args[2]),
+            self._print(expr.args[3]))
+
+    def _print_fresnels(self, expr):
+        return "{}({})[0]".format(
+                self._module_format("scipy.special.fresnel"),
+                self._print(expr.args[0]))
+
+    def _print_fresnelc(self, expr):
+        return "{}({})[1]".format(
+                self._module_format("scipy.special.fresnel"),
+                self._print(expr.args[0]))
+
+    def _print_airyai(self, expr):
+        return "{}({})[0]".format(
+                self._module_format("scipy.special.airy"),
+                self._print(expr.args[0]))
+
+    def _print_airyaiprime(self, expr):
+        return "{}({})[1]".format(
+                self._module_format("scipy.special.airy"),
+                self._print(expr.args[0]))
+
+    def _print_airybi(self, expr):
+        return "{}({})[2]".format(
+                self._module_format("scipy.special.airy"),
+                self._print(expr.args[0]))
+
+    def _print_airybiprime(self, expr):
+        return "{}({})[3]".format(
+                self._module_format("scipy.special.airy"),
+                self._print(expr.args[0]))
+
+    def _print_bernoulli(self, expr):
+        # scipy's bernoulli is inconsistent with SymPy's so rewrite
+        return self._print(expr._eval_rewrite_as_zeta(*expr.args))
+
+    def _print_harmonic(self, expr):
+        return self._print(expr._eval_rewrite_as_zeta(*expr.args))
+
+    def _print_Integral(self, e):
+        integration_vars, limits = _unpack_integral_limits(e)
+
+        if len(limits) == 1:
+            # nicer (but not necessary) to prefer quad over nquad for 1D case
+            module_str = self._module_format("scipy.integrate.quad")
+            limit_str = "%s, %s" % tuple(map(self._print, limits[0]))
+        else:
+            module_str = self._module_format("scipy.integrate.nquad")
+            limit_str = "({})".format(", ".join(
+                "(%s, %s)" % tuple(map(self._print, l)) for l in limits))
+
+        return "{}(lambda {}: {}, {})[0]".format(
+                module_str,
+                ", ".join(map(self._print, integration_vars)),
+                self._print(e.args[0]),
+                limit_str)
+
+    def _print_Si(self, expr):
+        return "{}({})[0]".format(
+                self._module_format("scipy.special.sici"),
+                self._print(expr.args[0]))
+
+    def _print_Ci(self, expr):
+        return "{}({})[1]".format(
+                self._module_format("scipy.special.sici"),
+                self._print(expr.args[0]))
+
+for func in _scipy_known_functions:
+    setattr(SciPyPrinter, f'_print_{func}', _print_known_func)
+
+for const in _scipy_known_constants:
+    setattr(SciPyPrinter, f'_print_{const}', _print_known_const)
+
+
+_cupy_known_functions = {k : "cupy." + v for k, v in _known_functions_numpy.items()}
+_cupy_known_constants = {k : "cupy." + v for k, v in _known_constants_numpy.items()}
+
+class CuPyPrinter(NumPyPrinter):
+    """
+    CuPy printer which handles vectorized piecewise functions,
+    logical operators, etc.
+    """
+
+    _module = 'cupy'
+    _kf = _cupy_known_functions
+    _kc = _cupy_known_constants
+
+    def __init__(self, settings=None):
+        super().__init__(settings=settings)
+
+for func in _cupy_known_functions:
+    setattr(CuPyPrinter, f'_print_{func}', _print_known_func)
+
+for const in _cupy_known_constants:
+    setattr(CuPyPrinter, f'_print_{const}', _print_known_const)
+
+
+_jax_known_functions = {k: 'jax.numpy.' + v for k, v in _known_functions_numpy.items()}
+_jax_known_constants = {k: 'jax.numpy.' + v for k, v in _known_constants_numpy.items()}
+
+class JaxPrinter(NumPyPrinter):
+    """
+    JAX printer which handles vectorized piecewise functions,
+    logical operators, etc.
+    """
+    _module = "jax.numpy"
+
+    _kf = _jax_known_functions
+    _kc = _jax_known_constants
+
+    def __init__(self, settings=None):
+        super().__init__(settings=settings)
+
+    # These need specific override to allow for the lack of "jax.numpy.reduce"
+    def _print_And(self, expr):
+        "Logical And printer"
+        return "{}({}.asarray([{}]), axis=0)".format(
+            self._module_format(self._module + ".all"),
+            self._module_format(self._module),
+            ",".join(self._print(i) for i in expr.args),
+        )
+
+    def _print_Or(self, expr):
+        "Logical Or printer"
+        return "{}({}.asarray([{}]), axis=0)".format(
+            self._module_format(self._module + ".any"),
+            self._module_format(self._module),
+            ",".join(self._print(i) for i in expr.args),
+        )
+
+for func in _jax_known_functions:
+    setattr(JaxPrinter, f'_print_{func}', _print_known_func)
+
+for const in _jax_known_constants:
+    setattr(JaxPrinter, f'_print_{const}', _print_known_const)

venv/lib/python3.10/site-packages/sympy/printing/pretty/__init__.py

@@ -0,0 +1,12 @@
+"""ASCII-ART 2D pretty-printer"""
+
+from .pretty import (pretty, pretty_print, pprint, pprint_use_unicode,
+    pprint_try_use_unicode, pager_print)
+
+# if unicode output is available -- let's use it
+pprint_try_use_unicode()
+
+__all__ = [
+    'pretty', 'pretty_print', 'pprint', 'pprint_use_unicode',
+    'pprint_try_use_unicode', 'pager_print',
+]