Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/sympy/printing/__init__.py

@@ -0,0 +1,116 @@
+"""Printing subsystem"""
+
+from .pretty import pager_print, pretty, pretty_print, pprint, pprint_use_unicode, pprint_try_use_unicode
+
+from .latex import latex, print_latex, multiline_latex
+
+from .mathml import mathml, print_mathml
+
+from .python import python, print_python
+
+from .pycode import pycode
+
+from .codeprinter import print_ccode, print_fcode
+
+from .codeprinter import ccode, fcode, cxxcode # noqa:F811
+
+from .smtlib import smtlib_code
+
+from .glsl import glsl_code, print_glsl
+
+from .rcode import rcode, print_rcode
+
+from .jscode import jscode, print_jscode
+
+from .julia import julia_code
+
+from .mathematica import mathematica_code
+
+from .octave import octave_code
+
+from .rust import rust_code
+
+from .gtk import print_gtk
+
+from .preview import preview
+
+from .repr import srepr
+
+from .tree import print_tree
+
+from .str import StrPrinter, sstr, sstrrepr
+
+from .tableform import TableForm
+
+from .dot import dotprint
+
+from .maple import maple_code, print_maple_code
+
+__all__ = [
+    # sympy.printing.pretty
+    'pager_print', 'pretty', 'pretty_print', 'pprint', 'pprint_use_unicode',
+    'pprint_try_use_unicode',
+
+    # sympy.printing.latex
+    'latex', 'print_latex', 'multiline_latex',
+
+    # sympy.printing.mathml
+    'mathml', 'print_mathml',
+
+    # sympy.printing.python
+    'python', 'print_python',
+
+    # sympy.printing.pycode
+    'pycode',
+
+    # sympy.printing.codeprinter
+    'ccode', 'print_ccode', 'cxxcode', 'fcode', 'print_fcode',
+
+    # sympy.printing.smtlib
+    'smtlib_code',
+
+    # sympy.printing.glsl
+    'glsl_code', 'print_glsl',
+
+    # sympy.printing.rcode
+    'rcode', 'print_rcode',
+
+    # sympy.printing.jscode
+    'jscode', 'print_jscode',
+
+    # sympy.printing.julia
+    'julia_code',
+
+    # sympy.printing.mathematica
+    'mathematica_code',
+
+    # sympy.printing.octave
+    'octave_code',
+
+    # sympy.printing.rust
+    'rust_code',
+
+    # sympy.printing.gtk
+    'print_gtk',
+
+    # sympy.printing.preview
+    'preview',
+
+    # sympy.printing.repr
+    'srepr',
+
+    # sympy.printing.tree
+    'print_tree',
+
+    # sympy.printing.str
+    'StrPrinter', 'sstr', 'sstrrepr',
+
+    # sympy.printing.tableform
+    'TableForm',
+
+    # sympy.printing.dot
+    'dotprint',
+
+    # sympy.printing.maple
+    'maple_code', 'print_maple_code',
+]

env-llmeval/lib/python3.10/site-packages/sympy/printing/codeprinter.py

@@ -0,0 +1,875 @@
+from __future__ import annotations
+from typing import Any
+
+from functools import wraps
+
+from sympy.core import Add, Mul, Pow, S, sympify, Float
+from sympy.core.basic import Basic
+from sympy.core.expr import UnevaluatedExpr
+from sympy.core.function import Lambda
+from sympy.core.mul import _keep_coeff
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.complexes import re
+from sympy.printing.str import StrPrinter
+from sympy.printing.precedence import precedence, PRECEDENCE
+
+
+class requires:
+    """ Decorator for registering requirements on print methods. """
+    def __init__(self, **kwargs):
+        self._req = kwargs
+
+    def __call__(self, method):
+        def _method_wrapper(self_, *args, **kwargs):
+            for k, v in self._req.items():
+                getattr(self_, k).update(v)
+            return method(self_, *args, **kwargs)
+        return wraps(method)(_method_wrapper)
+
+
+class AssignmentError(Exception):
+    """
+    Raised if an assignment variable for a loop is missing.
+    """
+    pass
+
+
+def _convert_python_lists(arg):
+    if isinstance(arg, list):
+        from sympy.codegen.abstract_nodes import List
+        return List(*(_convert_python_lists(e) for e in arg))
+    elif isinstance(arg, tuple):
+        return tuple(_convert_python_lists(e) for e in arg)
+    else:
+        return arg
+
+
+class CodePrinter(StrPrinter):
+    """
+    The base class for code-printing subclasses.
+    """
+
+    _operators = {
+        'and': '&&',
+        'or': '||',
+        'not': '!',
+    }
+
+    _default_settings: dict[str, Any] = {
+        'order': None,
+        'full_prec': 'auto',
+        'error_on_reserved': False,
+        'reserved_word_suffix': '_',
+        'human': True,
+        'inline': False,
+        'allow_unknown_functions': False,
+    }
+
+    # Functions which are "simple" to rewrite to other functions that
+    # may be supported
+    # function_to_rewrite : (function_to_rewrite_to, iterable_with_other_functions_required)
+    _rewriteable_functions = {
+            'cot': ('tan', []),
+            'csc': ('sin', []),
+            'sec': ('cos', []),
+            'acot': ('atan', []),
+            'acsc': ('asin', []),
+            'asec': ('acos', []),
+            'coth': ('exp', []),
+            'csch': ('exp', []),
+            'sech': ('exp', []),
+            'acoth': ('log', []),
+            'acsch': ('log', []),
+            'asech': ('log', []),
+            'catalan': ('gamma', []),
+            'fibonacci': ('sqrt', []),
+            'lucas': ('sqrt', []),
+            'beta': ('gamma', []),
+            'sinc': ('sin', ['Piecewise']),
+            'Mod': ('floor', []),
+            'factorial': ('gamma', []),
+            'factorial2': ('gamma', ['Piecewise']),
+            'subfactorial': ('uppergamma', []),
+            'RisingFactorial': ('gamma', ['Piecewise']),
+            'FallingFactorial': ('gamma', ['Piecewise']),
+            'binomial': ('gamma', []),
+            'frac': ('floor', []),
+            'Max': ('Piecewise', []),
+            'Min': ('Piecewise', []),
+            'Heaviside': ('Piecewise', []),
+            'erf2': ('erf', []),
+            'erfc': ('erf', []),
+            'Li': ('li', []),
+            'Ei': ('li', []),
+            'dirichlet_eta': ('zeta', []),
+            'riemann_xi': ('zeta', ['gamma']),
+    }
+
+    def __init__(self, settings=None):
+
+        super().__init__(settings=settings)
+        if not hasattr(self, 'reserved_words'):
+            self.reserved_words = set()
+
+    def _handle_UnevaluatedExpr(self, expr):
+        return expr.replace(re, lambda arg: arg if isinstance(
+            arg, UnevaluatedExpr) and arg.args[0].is_real else re(arg))
+
+    def doprint(self, expr, assign_to=None):
+        """
+        Print the expression as code.
+
+        Parameters
+        ----------
+        expr : Expression
+            The expression to be printed.
+
+        assign_to : Symbol, string, MatrixSymbol, list of strings or Symbols (optional)
+            If provided, the printed code will set the expression to a variable or multiple variables
+            with the name or names given in ``assign_to``.
+        """
+        from sympy.matrices.expressions.matexpr import MatrixSymbol
+        from sympy.codegen.ast import CodeBlock, Assignment
+
+        def _handle_assign_to(expr, assign_to):
+            if assign_to is None:
+                return sympify(expr)
+            if isinstance(assign_to, (list, tuple)):
+                if len(expr) != len(assign_to):
+                    raise ValueError('Failed to assign an expression of length {} to {} variables'.format(len(expr), len(assign_to)))
+                return CodeBlock(*[_handle_assign_to(lhs, rhs) for lhs, rhs in zip(expr, assign_to)])
+            if isinstance(assign_to, str):
+                if expr.is_Matrix:
+                    assign_to = MatrixSymbol(assign_to, *expr.shape)
+                else:
+                    assign_to = Symbol(assign_to)
+            elif not isinstance(assign_to, Basic):
+                raise TypeError("{} cannot assign to object of type {}".format(
+                        type(self).__name__, type(assign_to)))
+            return Assignment(assign_to, expr)
+
+        expr = _convert_python_lists(expr)
+        expr = _handle_assign_to(expr, assign_to)
+
+        # Remove re(...) nodes due to UnevaluatedExpr.is_real always is None:
+        expr = self._handle_UnevaluatedExpr(expr)
+
+        # keep a set of expressions that are not strictly translatable to Code
+        # and number constants that must be declared and initialized
+        self._not_supported = set()
+        self._number_symbols = set()
+
+        lines = self._print(expr).splitlines()
+
+        # format the output
+        if self._settings["human"]:
+            frontlines = []
+            if self._not_supported:
+                frontlines.append(self._get_comment(
+                        "Not supported in {}:".format(self.language)))
+                for expr in sorted(self._not_supported, key=str):
+                    frontlines.append(self._get_comment(type(expr).__name__))
+            for name, value in sorted(self._number_symbols, key=str):
+                frontlines.append(self._declare_number_const(name, value))
+            lines = frontlines + lines
+            lines = self._format_code(lines)
+            result = "\n".join(lines)
+        else:
+            lines = self._format_code(lines)
+            num_syms = {(k, self._print(v)) for k, v in self._number_symbols}
+            result = (num_syms, self._not_supported, "\n".join(lines))
+        self._not_supported = set()
+        self._number_symbols = set()
+        return result
+
+    def _doprint_loops(self, expr, assign_to=None):
+        # Here we print an expression that contains Indexed objects, they
+        # correspond to arrays in the generated code.  The low-level implementation
+        # involves looping over array elements and possibly storing results in temporary
+        # variables or accumulate it in the assign_to object.
+
+        if self._settings.get('contract', True):
+            from sympy.tensor import get_contraction_structure
+            # Setup loops over non-dummy indices  --  all terms need these
+            indices = self._get_expression_indices(expr, assign_to)
+            # Setup loops over dummy indices  --  each term needs separate treatment
+            dummies = get_contraction_structure(expr)
+        else:
+            indices = []
+            dummies = {None: (expr,)}
+        openloop, closeloop = self._get_loop_opening_ending(indices)
+
+        # terms with no summations first
+        if None in dummies:
+            text = StrPrinter.doprint(self, Add(*dummies[None]))
+        else:
+            # If all terms have summations we must initialize array to Zero
+            text = StrPrinter.doprint(self, 0)
+
+        # skip redundant assignments (where lhs == rhs)
+        lhs_printed = self._print(assign_to)
+        lines = []
+        if text != lhs_printed:
+            lines.extend(openloop)
+            if assign_to is not None:
+                text = self._get_statement("%s = %s" % (lhs_printed, text))
+            lines.append(text)
+            lines.extend(closeloop)
+
+        # then terms with summations
+        for d in dummies:
+            if isinstance(d, tuple):
+                indices = self._sort_optimized(d, expr)
+                openloop_d, closeloop_d = self._get_loop_opening_ending(
+                    indices)
+
+                for term in dummies[d]:
+                    if term in dummies and not ([list(f.keys()) for f in dummies[term]]
+                            == [[None] for f in dummies[term]]):
+                        # If one factor in the term has it's own internal
+                        # contractions, those must be computed first.
+                        # (temporary variables?)
+                        raise NotImplementedError(
+                            "FIXME: no support for contractions in factor yet")
+                    else:
+
+                        # We need the lhs expression as an accumulator for
+                        # the loops, i.e
+                        #
+                        # for (int d=0; d < dim; d++){
+                        #    lhs[] = lhs[] + term[][d]
+                        # }           ^.................. the accumulator
+                        #
+                        # We check if the expression already contains the
+                        # lhs, and raise an exception if it does, as that
+                        # syntax is currently undefined.  FIXME: What would be
+                        # a good interpretation?
+                        if assign_to is None:
+                            raise AssignmentError(
+                                "need assignment variable for loops")
+                        if term.has(assign_to):
+                            raise ValueError("FIXME: lhs present in rhs,\
+                                this is undefined in CodePrinter")
+
+                        lines.extend(openloop)
+                        lines.extend(openloop_d)
+                        text = "%s = %s" % (lhs_printed, StrPrinter.doprint(
+                            self, assign_to + term))
+                        lines.append(self._get_statement(text))
+                        lines.extend(closeloop_d)
+                        lines.extend(closeloop)
+
+        return "\n".join(lines)
+
+    def _get_expression_indices(self, expr, assign_to):
+        from sympy.tensor import get_indices
+        rinds, junk = get_indices(expr)
+        linds, junk = get_indices(assign_to)
+
+        # support broadcast of scalar
+        if linds and not rinds:
+            rinds = linds
+        if rinds != linds:
+            raise ValueError("lhs indices must match non-dummy"
+                    " rhs indices in %s" % expr)
+
+        return self._sort_optimized(rinds, assign_to)
+
+    def _sort_optimized(self, indices, expr):
+
+        from sympy.tensor.indexed import Indexed
+
+        if not indices:
+            return []
+
+        # determine optimized loop order by giving a score to each index
+        # the index with the highest score are put in the innermost loop.
+        score_table = {}
+        for i in indices:
+            score_table[i] = 0
+
+        arrays = expr.atoms(Indexed)
+        for arr in arrays:
+            for p, ind in enumerate(arr.indices):
+                try:
+                    score_table[ind] += self._rate_index_position(p)
+                except KeyError:
+                    pass
+
+        return sorted(indices, key=lambda x: score_table[x])
+
+    def _rate_index_position(self, p):
+        """function to calculate score based on position among indices
+
+        This method is used to sort loops in an optimized order, see
+        CodePrinter._sort_optimized()
+        """
+        raise NotImplementedError("This function must be implemented by "
+                                  "subclass of CodePrinter.")
+
+    def _get_statement(self, codestring):
+        """Formats a codestring with the proper line ending."""
+        raise NotImplementedError("This function must be implemented by "
+                                  "subclass of CodePrinter.")
+
+    def _get_comment(self, text):
+        """Formats a text string as a comment."""
+        raise NotImplementedError("This function must be implemented by "
+                                  "subclass of CodePrinter.")
+
+    def _declare_number_const(self, name, value):
+        """Declare a numeric constant at the top of a function"""
+        raise NotImplementedError("This function must be implemented by "
+                                  "subclass of CodePrinter.")
+
+    def _format_code(self, lines):
+        """Take in a list of lines of code, and format them accordingly.
+
+        This may include indenting, wrapping long lines, etc..."""
+        raise NotImplementedError("This function must be implemented by "
+                                  "subclass of CodePrinter.")
+
+    def _get_loop_opening_ending(self, indices):
+        """Returns a tuple (open_lines, close_lines) containing lists
+        of codelines"""
+        raise NotImplementedError("This function must be implemented by "
+                                  "subclass of CodePrinter.")
+
+    def _print_Dummy(self, expr):
+        if expr.name.startswith('Dummy_'):
+            return '_' + expr.name
+        else:
+            return '%s_%d' % (expr.name, expr.dummy_index)
+
+    def _print_CodeBlock(self, expr):
+        return '\n'.join([self._print(i) for i in expr.args])
+
+    def _print_String(self, string):
+        return str(string)
+
+    def _print_QuotedString(self, arg):
+        return '"%s"' % arg.text
+
+    def _print_Comment(self, string):
+        return self._get_comment(str(string))
+
+    def _print_Assignment(self, expr):
+        from sympy.codegen.ast import Assignment
+        from sympy.functions.elementary.piecewise import Piecewise
+        from sympy.matrices.expressions.matexpr import MatrixSymbol
+        from sympy.tensor.indexed import IndexedBase
+        lhs = expr.lhs
+        rhs = expr.rhs
+        # We special case assignments that take multiple lines
+        if isinstance(expr.rhs, Piecewise):
+            # Here we modify Piecewise so each expression is now
+            # an Assignment, and then continue on the print.
+            expressions = []
+            conditions = []
+            for (e, c) in rhs.args:
+                expressions.append(Assignment(lhs, e))
+                conditions.append(c)
+            temp = Piecewise(*zip(expressions, conditions))
+            return self._print(temp)
+        elif isinstance(lhs, MatrixSymbol):
+            # Here we form an Assignment for each element in the array,
+            # printing each one.
+            lines = []
+            for (i, j) in self._traverse_matrix_indices(lhs):
+                temp = Assignment(lhs[i, j], rhs[i, j])
+                code0 = self._print(temp)
+                lines.append(code0)
+            return "\n".join(lines)
+        elif self._settings.get("contract", False) and (lhs.has(IndexedBase) or
+                rhs.has(IndexedBase)):
+            # Here we check if there is looping to be done, and if so
+            # print the required loops.
+            return self._doprint_loops(rhs, lhs)
+        else:
+            lhs_code = self._print(lhs)
+            rhs_code = self._print(rhs)
+            return self._get_statement("%s = %s" % (lhs_code, rhs_code))
+
+    def _print_AugmentedAssignment(self, expr):
+        lhs_code = self._print(expr.lhs)
+        rhs_code = self._print(expr.rhs)
+        return self._get_statement("{} {} {}".format(
+            *(self._print(arg) for arg in [lhs_code, expr.op, rhs_code])))
+
+    def _print_FunctionCall(self, expr):
+        return '%s(%s)' % (
+            expr.name,
+            ', '.join((self._print(arg) for arg in expr.function_args)))
+
+    def _print_Variable(self, expr):
+        return self._print(expr.symbol)
+
+    def _print_Symbol(self, expr):
+
+        name = super()._print_Symbol(expr)
+
+        if name in self.reserved_words:
+            if self._settings['error_on_reserved']:
+                msg = ('This expression includes the symbol "{}" which is a '
+                       'reserved keyword in this language.')
+                raise ValueError(msg.format(name))
+            return name + self._settings['reserved_word_suffix']
+        else:
+            return name
+
+    def _can_print(self, name):
+        """ Check if function ``name`` is either a known function or has its own
+            printing method. Used to check if rewriting is possible."""
+        return name in self.known_functions or getattr(self, '_print_{}'.format(name), False)
+
+    def _print_Function(self, expr):
+        if expr.func.__name__ in self.known_functions:
+            cond_func = self.known_functions[expr.func.__name__]
+            if isinstance(cond_func, str):
+                return "%s(%s)" % (cond_func, self.stringify(expr.args, ", "))
+            else:
+                for cond, func in cond_func:
+                    if cond(*expr.args):
+                        break
+                if func is not None:
+                    try:
+                        return func(*[self.parenthesize(item, 0) for item in expr.args])
+                    except TypeError:
+                        return "%s(%s)" % (func, self.stringify(expr.args, ", "))
+        elif hasattr(expr, '_imp_') and isinstance(expr._imp_, Lambda):
+            # inlined function
+            return self._print(expr._imp_(*expr.args))
+        elif expr.func.__name__ in self._rewriteable_functions:
+            # Simple rewrite to supported function possible
+            target_f, required_fs = self._rewriteable_functions[expr.func.__name__]
+            if self._can_print(target_f) and all(self._can_print(f) for f in required_fs):
+                return self._print(expr.rewrite(target_f))
+        if expr.is_Function and self._settings.get('allow_unknown_functions', False):
+            return '%s(%s)' % (self._print(expr.func), ', '.join(map(self._print, expr.args)))
+        else:
+            return self._print_not_supported(expr)
+
+    _print_Expr = _print_Function
+
+    # Don't inherit the str-printer method for Heaviside to the code printers
+    _print_Heaviside = None
+
+    def _print_NumberSymbol(self, expr):
+        if self._settings.get("inline", False):
+            return self._print(Float(expr.evalf(self._settings["precision"])))
+        else:
+            # 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 _print_Catalan(self, expr):
+        return self._print_NumberSymbol(expr)
+    def _print_EulerGamma(self, expr):
+        return self._print_NumberSymbol(expr)
+    def _print_GoldenRatio(self, expr):
+        return self._print_NumberSymbol(expr)
+    def _print_TribonacciConstant(self, expr):
+        return self._print_NumberSymbol(expr)
+    def _print_Exp1(self, expr):
+        return self._print_NumberSymbol(expr)
+    def _print_Pi(self, expr):
+        return self._print_NumberSymbol(expr)
+
+    def _print_And(self, expr):
+        PREC = precedence(expr)
+        return (" %s " % self._operators['and']).join(self.parenthesize(a, PREC)
+                for a in sorted(expr.args, key=default_sort_key))
+
+    def _print_Or(self, expr):
+        PREC = precedence(expr)
+        return (" %s " % self._operators['or']).join(self.parenthesize(a, PREC)
+                for a in sorted(expr.args, key=default_sort_key))
+
+    def _print_Xor(self, expr):
+        if self._operators.get('xor') is None:
+            return self._print(expr.to_nnf())
+        PREC = precedence(expr)
+        return (" %s " % self._operators['xor']).join(self.parenthesize(a, PREC)
+                for a in expr.args)
+
+    def _print_Equivalent(self, expr):
+        if self._operators.get('equivalent') is None:
+            return self._print(expr.to_nnf())
+        PREC = precedence(expr)
+        return (" %s " % self._operators['equivalent']).join(self.parenthesize(a, PREC)
+                for a in expr.args)
+
+    def _print_Not(self, expr):
+        PREC = precedence(expr)
+        return self._operators['not'] + self.parenthesize(expr.args[0], PREC)
+
+    def _print_BooleanFunction(self, expr):
+        return self._print(expr.to_nnf())
+
+    def _print_Mul(self, expr):
+
+        prec = precedence(expr)
+
+        c, e = expr.as_coeff_Mul()
+        if c < 0:
+            expr = _keep_coeff(-c, e)
+            sign = "-"
+        else:
+            sign = ""
+
+        a = []  # items in the numerator
+        b = []  # items that are in the denominator (if any)
+
+        pow_paren = []  # Will collect all pow with more than one base element and exp = -1
+
+        if self.order not in ('old', 'none'):
+            args = expr.as_ordered_factors()
+        else:
+            # use make_args in case expr was something like -x -> x
+            args = Mul.make_args(expr)
+
+        # Gather args for numerator/denominator
+        for item in args:
+            if item.is_commutative and item.is_Pow and item.exp.is_Rational and item.exp.is_negative:
+                if item.exp != -1:
+                    b.append(Pow(item.base, -item.exp, evaluate=False))
+                else:
+                    if len(item.args[0].args) != 1 and isinstance(item.base, Mul):   # To avoid situations like #14160
+                        pow_paren.append(item)
+                    b.append(Pow(item.base, -item.exp))
+            else:
+                a.append(item)
+
+        a = a or [S.One]
+
+        if len(a) == 1 and sign == "-":
+            # Unary minus does not have a SymPy class, and hence there's no
+            # precedence weight associated with it, Python's unary minus has
+            # an operator precedence between multiplication and exponentiation,
+            # so we use this to compute a weight.
+            a_str = [self.parenthesize(a[0], 0.5*(PRECEDENCE["Pow"]+PRECEDENCE["Mul"]))]
+        else:
+            a_str = [self.parenthesize(x, prec) for x in a]
+        b_str = [self.parenthesize(x, prec) for x in b]
+
+        # To parenthesize Pow with exp = -1 and having more than one Symbol
+        for item in pow_paren:
+            if item.base in b:
+                b_str[b.index(item.base)] = "(%s)" % b_str[b.index(item.base)]
+
+        if not b:
+            return sign + '*'.join(a_str)
+        elif len(b) == 1:
+            return sign + '*'.join(a_str) + "/" + b_str[0]
+        else:
+            return sign + '*'.join(a_str) + "/(%s)" % '*'.join(b_str)
+
+    def _print_not_supported(self, expr):
+        try:
+            self._not_supported.add(expr)
+        except TypeError:
+            # not hashable
+            pass
+        return self.emptyPrinter(expr)
+
+    # The following can not be simply translated into C or Fortran
+    _print_Basic = _print_not_supported
+    _print_ComplexInfinity = _print_not_supported
+    _print_Derivative = _print_not_supported
+    _print_ExprCondPair = _print_not_supported
+    _print_GeometryEntity = _print_not_supported
+    _print_Infinity = _print_not_supported
+    _print_Integral = _print_not_supported
+    _print_Interval = _print_not_supported
+    _print_AccumulationBounds = _print_not_supported
+    _print_Limit = _print_not_supported
+    _print_MatrixBase = _print_not_supported
+    _print_DeferredVector = _print_not_supported
+    _print_NaN = _print_not_supported
+    _print_NegativeInfinity = _print_not_supported
+    _print_Order = _print_not_supported
+    _print_RootOf = _print_not_supported
+    _print_RootsOf = _print_not_supported
+    _print_RootSum = _print_not_supported
+    _print_Uniform = _print_not_supported
+    _print_Unit = _print_not_supported
+    _print_Wild = _print_not_supported
+    _print_WildFunction = _print_not_supported
+    _print_Relational = _print_not_supported
+
+
+# Code printer functions. These are included in this file so that they can be
+# imported in the top-level __init__.py without importing the sympy.codegen
+# module.
+
+def ccode(expr, assign_to=None, standard='c99', **settings):
+    """Converts an expr to a string of c 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.
+    standard : str, optional
+        String specifying the standard. If your compiler supports a more modern
+        standard you may set this to 'c99' to allow the printer to use more math
+        functions. [default='c89'].
+    precision : integer, optional
+        The precision for numbers such as pi [default=17].
+    user_functions : dict, optional
+        A dictionary where the keys are string representations of either
+        ``FunctionClass`` or ``UndefinedFunction`` instances and the values
+        are their desired C string representations. Alternatively, the
+        dictionary value can be a list of tuples i.e. [(argument_test,
+        cfunction_string)] or [(argument_test, cfunction_formater)]. See below
+        for examples.
+    dereference : iterable, optional
+        An iterable of symbols that should be dereferenced in the printed code
+        expression. These would be values passed by address to the function.
+        For example, if ``dereference=[a]``, the resulting code would print
+        ``(*a)`` instead of ``a``.
+    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 ccode, symbols, Rational, sin, ceiling, Abs, Function
+    >>> x, tau = symbols("x, tau")
+    >>> expr = (2*tau)**Rational(7, 2)
+    >>> ccode(expr)
+    '8*M_SQRT2*pow(tau, 7.0/2.0)'
+    >>> ccode(expr, math_macros={})
+    '8*sqrt(2)*pow(tau, 7.0/2.0)'
+    >>> ccode(sin(x), assign_to="s")
+    's = sin(x);'
+    >>> from sympy.codegen.ast import real, float80
+    >>> ccode(expr, type_aliases={real: float80})
+    '8*M_SQRT2l*powl(tau, 7.0L/2.0L)'
+
+    Simple 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, cfunction_string)].
+
+    >>> custom_functions = {
+    ...   "ceiling": "CEIL",
+    ...   "Abs": [(lambda x: not x.is_integer, "fabs"),
+    ...           (lambda x: x.is_integer, "ABS")],
+    ...   "func": "f"
+    ... }
+    >>> func = Function('func')
+    >>> ccode(func(Abs(x) + ceiling(x)), standard='C89', user_functions=custom_functions)
+    'f(fabs(x) + CEIL(x))'
+
+    or if the C-function takes a subset of the original arguments:
+
+    >>> ccode(2**x + 3**x, standard='C99', user_functions={'Pow': [
+    ...   (lambda b, e: b == 2, lambda b, e: 'exp2(%s)' % e),
+    ...   (lambda b, e: b != 2, 'pow')]})
+    'exp2(x) + pow(3, 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(ccode(expr, tau, standard='C89'))
+    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]))
+    >>> ccode(e.rhs, assign_to=e.lhs, contract=False, standard='C89')
+    '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(ccode(mat, A, standard='C89'))
+    A[0] = pow(x, 2);
+    if (x > 0) {
+       A[1] = x + 1;
+    }
+    else {
+       A[1] = x;
+    }
+    A[2] = sin(x);
+    """
+    from sympy.printing.c import c_code_printers
+    return c_code_printers[standard.lower()](settings).doprint(expr, assign_to)
+
+def print_ccode(expr, **settings):
+    """Prints C representation of the given expression."""
+    print(ccode(expr, **settings))
+
+def fcode(expr, assign_to=None, **settings):
+    """Converts an expr to a string of fortran 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
+        DEPRECATED. Use type_mappings instead. The precision for numbers such
+        as pi [default=17].
+    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].
+    source_format : optional
+        The source format can be either 'fixed' or 'free'. [default='fixed']
+    standard : integer, optional
+        The Fortran standard to be followed. This is specified as an integer.
+        Acceptable standards are 66, 77, 90, 95, 2003, and 2008. Default is 77.
+        Note that currently the only distinction internally is between
+        standards before 95, and those 95 and after. This may change later as
+        more features are added.
+    name_mangling : bool, optional
+        If True, then the variables that would become identical in
+        case-insensitive Fortran are mangled by appending different number
+        of ``_`` at the end. If False, SymPy Will not interfere with naming of
+        variables. [default=True]
+
+    Examples
+    ========
+
+    >>> from sympy import fcode, symbols, Rational, sin, ceiling, floor
+    >>> x, tau = symbols("x, tau")
+    >>> fcode((2*tau)**Rational(7, 2))
+    '      8*sqrt(2.0d0)*tau**(7.0d0/2.0d0)'
+    >>> fcode(sin(x), assign_to="s")
+    '      s = 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,
+    cfunction_string)].
+
+    >>> custom_functions = {
+    ...   "ceiling": "CEIL",
+    ...   "floor": [(lambda x: not x.is_integer, "FLOOR1"),
+    ...             (lambda x: x.is_integer, "FLOOR2")]
+    ... }
+    >>> fcode(floor(x) + ceiling(x), user_functions=custom_functions)
+    '      CEIL(x) + FLOOR1(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(fcode(expr, tau))
+          if (x > 0) then
+             tau = x + 1
+          else
+             tau = x
+          end if
+
+    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]))
+    >>> fcode(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(fcode(mat, A))
+          A(1, 1) = x**2
+             if (x > 0) then
+          A(2, 1) = x + 1
+             else
+          A(2, 1) = x
+             end if
+          A(3, 1) = sin(x)
+    """
+    from sympy.printing.fortran import FCodePrinter
+    return FCodePrinter(settings).doprint(expr, assign_to)
+
+
+def print_fcode(expr, **settings):
+    """Prints the Fortran representation of the given expression.
+
+       See fcode for the meaning of the optional arguments.
+    """
+    print(fcode(expr, **settings))
+
+def cxxcode(expr, assign_to=None, standard='c++11', **settings):
+    """ C++ equivalent of :func:`~.ccode`. """
+    from sympy.printing.cxx import cxx_code_printers
+    return cxx_code_printers[standard.lower()](settings).doprint(expr, assign_to)

env-llmeval/lib/python3.10/site-packages/sympy/printing/cxx.py

@@ -0,0 +1,169 @@
+"""
+C++ code printer
+"""
+
+from itertools import chain
+from sympy.codegen.ast import Type, none
+from .c import C89CodePrinter, C99CodePrinter
+
+# 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 cxxcode # noqa:F401
+
+# from https://en.cppreference.com/w/cpp/keyword
+reserved = {
+    'C++98': [
+        'and', 'and_eq', 'asm', 'auto', 'bitand', 'bitor', 'bool', 'break',
+        'case', 'catch,', 'char', 'class', 'compl', 'const', 'const_cast',
+        'continue', 'default', 'delete', 'do', 'double', 'dynamic_cast',
+        'else', 'enum', 'explicit', 'export', 'extern', 'false', 'float',
+        'for', 'friend', 'goto', 'if', 'inline', 'int', 'long', 'mutable',
+        'namespace', 'new', 'not', 'not_eq', 'operator', 'or', 'or_eq',
+        'private', 'protected', 'public', 'register', 'reinterpret_cast',
+        'return', 'short', 'signed', 'sizeof', 'static', 'static_cast',
+        'struct', 'switch', 'template', 'this', 'throw', 'true', 'try',
+        'typedef', 'typeid', 'typename', 'union', 'unsigned', 'using',
+        'virtual', 'void', 'volatile', 'wchar_t', 'while', 'xor', 'xor_eq'
+    ]
+}
+
+reserved['C++11'] = reserved['C++98'][:] + [
+    'alignas', 'alignof', 'char16_t', 'char32_t', 'constexpr', 'decltype',
+    'noexcept', 'nullptr', 'static_assert', 'thread_local'
+]
+reserved['C++17'] = reserved['C++11'][:]
+reserved['C++17'].remove('register')
+# TM TS: atomic_cancel, atomic_commit, atomic_noexcept, synchronized
+# concepts TS: concept, requires
+# module TS: import, module
+
+
+_math_functions = {
+    'C++98': {
+        'Mod': 'fmod',
+        'ceiling': 'ceil',
+    },
+    'C++11': {
+        'gamma': 'tgamma',
+    },
+    'C++17': {
+        'beta': 'beta',
+        'Ei': 'expint',
+        'zeta': 'riemann_zeta',
+    }
+}
+
+# from https://en.cppreference.com/w/cpp/header/cmath
+for k in ('Abs', 'exp', 'log', 'log10', 'sqrt', 'sin', 'cos', 'tan',  # 'Pow'
+          'asin', 'acos', 'atan', 'atan2', 'sinh', 'cosh', 'tanh', 'floor'):
+    _math_functions['C++98'][k] = k.lower()
+
+
+for k in ('asinh', 'acosh', 'atanh', 'erf', 'erfc'):
+    _math_functions['C++11'][k] = k.lower()
+
+
+def _attach_print_method(cls, sympy_name, func_name):
+    meth_name = '_print_%s' % sympy_name
+    if hasattr(cls, meth_name):
+        raise ValueError("Edit method (or subclass) instead of overwriting.")
+    def _print_method(self, expr):
+        return '{}{}({})'.format(self._ns, func_name, ', '.join(map(self._print, expr.args)))
+    _print_method.__doc__ = "Prints code for %s" % k
+    setattr(cls, meth_name, _print_method)
+
+
+def _attach_print_methods(cls, cont):
+    for sympy_name, cxx_name in cont[cls.standard].items():
+        _attach_print_method(cls, sympy_name, cxx_name)
+
+
+class _CXXCodePrinterBase:
+    printmethod = "_cxxcode"
+    language = 'C++'
+    _ns = 'std::'  # namespace
+
+    def __init__(self, settings=None):
+        super().__init__(settings or {})
+
+    def _print_Max(self, expr):
+        from sympy.functions.elementary.miscellaneous import Max
+        if len(expr.args) == 1:
+            return self._print(expr.args[0])
+        return "%smax(%s, %s)" % (self._ns, self._print(expr.args[0]),
+                                  self._print(Max(*expr.args[1:])))
+
+    def _print_Min(self, expr):
+        from sympy.functions.elementary.miscellaneous import Min
+        if len(expr.args) == 1:
+            return self._print(expr.args[0])
+        return "%smin(%s, %s)" % (self._ns, self._print(expr.args[0]),
+                                  self._print(Min(*expr.args[1:])))
+
+    def _print_using(self, expr):
+        if expr.alias == none:
+            return 'using %s' % expr.type
+        else:
+            raise ValueError("C++98 does not support type aliases")
+
+
+class CXX98CodePrinter(_CXXCodePrinterBase, C89CodePrinter):
+    standard = 'C++98'
+    reserved_words = set(reserved['C++98'])
+
+
+# _attach_print_methods(CXX98CodePrinter, _math_functions)
+
+
+class CXX11CodePrinter(_CXXCodePrinterBase, C99CodePrinter):
+    standard = 'C++11'
+    reserved_words = set(reserved['C++11'])
+    type_mappings = dict(chain(
+        CXX98CodePrinter.type_mappings.items(),
+        {
+            Type('int8'): ('int8_t', {'cstdint'}),
+            Type('int16'): ('int16_t', {'cstdint'}),
+            Type('int32'): ('int32_t', {'cstdint'}),
+            Type('int64'): ('int64_t', {'cstdint'}),
+            Type('uint8'): ('uint8_t', {'cstdint'}),
+            Type('uint16'): ('uint16_t', {'cstdint'}),
+            Type('uint32'): ('uint32_t', {'cstdint'}),
+            Type('uint64'): ('uint64_t', {'cstdint'}),
+            Type('complex64'): ('std::complex<float>', {'complex'}),
+            Type('complex128'): ('std::complex<double>', {'complex'}),
+            Type('bool'): ('bool', None),
+        }.items()
+    ))
+
+    def _print_using(self, expr):
+        if expr.alias == none:
+            return super()._print_using(expr)
+        else:
+            return 'using %(alias)s = %(type)s' % expr.kwargs(apply=self._print)
+
+# _attach_print_methods(CXX11CodePrinter, _math_functions)
+
+
+class CXX17CodePrinter(_CXXCodePrinterBase, C99CodePrinter):
+    standard = 'C++17'
+    reserved_words = set(reserved['C++17'])
+
+    _kf = dict(C99CodePrinter._kf, **_math_functions['C++17'])
+
+    def _print_beta(self, expr):
+        return self._print_math_func(expr)
+
+    def _print_Ei(self, expr):
+        return self._print_math_func(expr)
+
+    def _print_zeta(self, expr):
+        return self._print_math_func(expr)
+
+
+# _attach_print_methods(CXX17CodePrinter, _math_functions)
+
+cxx_code_printers = {
+    'c++98': CXX98CodePrinter,
+    'c++11': CXX11CodePrinter,
+    'c++17': CXX17CodePrinter
+}

env-llmeval/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

env-llmeval/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))
+        )

env-llmeval/lib/python3.10/site-packages/sympy/printing/glsl.py

@@ -0,0 +1,557 @@
+from __future__ import annotations
+
+from sympy.core import Basic, S
+from sympy.core.function import Lambda
+from sympy.core.numbers import equal_valued
+from sympy.printing.codeprinter import CodePrinter
+from sympy.printing.precedence import precedence
+from functools import reduce
+
+known_functions = {
+    'Abs': 'abs',
+    'sin': 'sin',
+    'cos': 'cos',
+    'tan': 'tan',
+    'acos': 'acos',
+    'asin': 'asin',
+    'atan': 'atan',
+    'atan2': 'atan',
+    'ceiling': 'ceil',
+    'floor': 'floor',
+    'sign': 'sign',
+    'exp': 'exp',
+    'log': 'log',
+    'add': 'add',
+    'sub': 'sub',
+    'mul': 'mul',
+    'pow': 'pow'
+}
+
+class GLSLPrinter(CodePrinter):
+    """
+    Rudimentary, generic GLSL printing tools.
+
+    Additional settings:
+    'use_operators': Boolean (should the printer use operators for +,-,*, or functions?)
+    """
+    _not_supported: set[Basic] = set()
+    printmethod = "_glsl"
+    language = "GLSL"
+
+    _default_settings = {
+        'use_operators': True,
+        'zero': 0,
+        'mat_nested': False,
+        'mat_separator': ',\n',
+        'mat_transpose': False,
+        'array_type': 'float',
+        'glsl_types': True,
+
+        'order': None,
+        'full_prec': 'auto',
+        'precision': 9,
+        'user_functions': {},
+        'human': True,
+        'allow_unknown_functions': False,
+        'contract': True,
+        'error_on_reserved': False,
+        'reserved_word_suffix': '_',
+    }
+
+    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 "float {} = {};".format(name, value)
+
+    def _format_code(self, lines):
+        return self.indent_code(lines)
+
+    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 _print_MatrixBase(self, mat):
+        mat_separator = self._settings['mat_separator']
+        mat_transpose = self._settings['mat_transpose']
+        column_vector = (mat.rows == 1) if mat_transpose else (mat.cols == 1)
+        A = mat.transpose() if mat_transpose != column_vector else mat
+
+        glsl_types = self._settings['glsl_types']
+        array_type = self._settings['array_type']
+        array_size = A.cols*A.rows
+        array_constructor = "{}[{}]".format(array_type, array_size)
+
+        if A.cols == 1:
+            return self._print(A[0]);
+        if A.rows <= 4 and A.cols <= 4 and glsl_types:
+            if A.rows == 1:
+                return "vec{}{}".format(
+                    A.cols, A.table(self,rowstart='(',rowend=')')
+                )
+            elif A.rows == A.cols:
+                return "mat{}({})".format(
+                    A.rows, A.table(self,rowsep=', ',
+                    rowstart='',rowend='')
+                )
+            else:
+                return "mat{}x{}({})".format(
+                    A.cols, A.rows,
+                    A.table(self,rowsep=', ',
+                    rowstart='',rowend='')
+                )
+        elif S.One in A.shape:
+            return "{}({})".format(
+                array_constructor,
+                A.table(self,rowsep=mat_separator,rowstart='',rowend='')
+            )
+        elif not self._settings['mat_nested']:
+            return "{}(\n{}\n) /* a {}x{} matrix */".format(
+                array_constructor,
+                A.table(self,rowsep=mat_separator,rowstart='',rowend=''),
+                A.rows, A.cols
+            )
+        elif self._settings['mat_nested']:
+            return "{}[{}][{}](\n{}\n)".format(
+                array_type, A.rows, A.cols,
+                A.table(self,rowsep=mat_separator,rowstart='float[](',rowend=')')
+            )
+
+    def _print_SparseRepMatrix(self, mat):
+        # do not allow sparse matrices to be made dense
+        return self._print_not_supported(mat)
+
+    def _traverse_matrix_indices(self, mat):
+        mat_transpose = self._settings['mat_transpose']
+        if mat_transpose:
+            rows,cols = mat.shape
+        else:
+            cols,rows = mat.shape
+        return ((i, j) for i in range(cols) for j in range(rows))
+
+    def _print_MatrixElement(self, expr):
+        # print('begin _print_MatrixElement')
+        nest = self._settings['mat_nested'];
+        glsl_types = self._settings['glsl_types'];
+        mat_transpose = self._settings['mat_transpose'];
+        if mat_transpose:
+            cols,rows = expr.parent.shape
+            i,j = expr.j,expr.i
+        else:
+            rows,cols = expr.parent.shape
+            i,j = expr.i,expr.j
+        pnt = self._print(expr.parent)
+        if glsl_types and ((rows <= 4 and cols <=4) or nest):
+            return "{}[{}][{}]".format(pnt, i, j)
+        else:
+            return "{}[{}]".format(pnt, i + j*rows)
+
+    def _print_list(self, expr):
+        l = ', '.join(self._print(item) for item in expr)
+        glsl_types = self._settings['glsl_types']
+        array_type = self._settings['array_type']
+        array_size = len(expr)
+        array_constructor = '{}[{}]'.format(array_type, array_size)
+
+        if array_size <= 4 and glsl_types:
+            return 'vec{}({})'.format(array_size, l)
+        else:
+            return '{}({})'.format(array_constructor, l)
+
+    _print_tuple = _print_list
+    _print_Tuple = _print_list
+
+    def _get_loop_opening_ending(self, indices):
+        open_lines = []
+        close_lines = []
+        loopstart = "for (int %(varble)s=%(start)s; %(varble)s<%(end)s; %(varble)s++){"
+        for i in indices:
+            # GLSL 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_Function_with_args(self, func, func_args):
+        if func in self.known_functions:
+            cond_func = self.known_functions[func]
+            func = None
+            if isinstance(cond_func, str):
+                func = cond_func
+            else:
+                for cond, func in cond_func:
+                    if cond(func_args):
+                        break
+            if func is not None:
+                try:
+                    return func(*[self.parenthesize(item, 0) for item in func_args])
+                except TypeError:
+                    return '{}({})'.format(func, self.stringify(func_args, ", "))
+        elif isinstance(func, Lambda):
+            # inlined function
+            return self._print(func(*func_args))
+        else:
+            return self._print_not_supported(func)
+
+    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_Idx(self, expr):
+        return self._print(expr.label)
+
+    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 "{}[{}]".format(
+            self._print(expr.base.label),
+            self._print(elem)
+        )
+
+    def _print_Pow(self, expr):
+        PREC = precedence(expr)
+        if equal_valued(expr.exp, -1):
+            return '1.0/%s' % (self.parenthesize(expr.base, PREC))
+        elif equal_valued(expr.exp, 0.5):
+            return 'sqrt(%s)' % self._print(expr.base)
+        else:
+            try:
+                e = self._print(float(expr.exp))
+            except TypeError:
+                e = self._print(expr.exp)
+            return self._print_Function_with_args('pow', (
+                self._print(expr.base),
+                e
+            ))
+
+    def _print_int(self, expr):
+        return str(float(expr))
+
+    def _print_Rational(self, expr):
+        return "{}.0/{}.0".format(expr.p, expr.q)
+
+    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_Add(self, expr, order=None):
+        if self._settings['use_operators']:
+            return CodePrinter._print_Add(self, expr, order=order)
+
+        terms = expr.as_ordered_terms()
+
+        def partition(p,l):
+            return reduce(lambda x, y: (x[0]+[y], x[1]) if p(y) else (x[0], x[1]+[y]), l,  ([], []))
+        def add(a,b):
+            return self._print_Function_with_args('add', (a, b))
+            # return self.known_functions['add']+'(%s, %s)' % (a,b)
+        neg, pos = partition(lambda arg: arg.could_extract_minus_sign(), terms)
+        if pos:
+            s = pos = reduce(lambda a,b: add(a,b), (self._print(t) for t in pos))
+        else:
+            s = pos = self._print(self._settings['zero'])
+
+        if neg:
+            # sum the absolute values of the negative terms
+            neg = reduce(lambda a,b: add(a,b), (self._print(-n) for n in neg))
+            # then subtract them from the positive terms
+            s = self._print_Function_with_args('sub', (pos,neg))
+            # s = self.known_functions['sub']+'(%s, %s)' % (pos,neg)
+        return s
+
+    def _print_Mul(self, expr, **kwargs):
+        if self._settings['use_operators']:
+            return CodePrinter._print_Mul(self, expr, **kwargs)
+        terms = expr.as_ordered_factors()
+        def mul(a,b):
+            # return self.known_functions['mul']+'(%s, %s)' % (a,b)
+            return self._print_Function_with_args('mul', (a,b))
+
+        s = reduce(lambda a,b: mul(a,b), (self._print(t) for t in terms))
+        return s
+
+def glsl_code(expr,assign_to=None,**settings):
+    """Converts an expr to a string of GLSL code
+
+    Parameters
+    ==========
+
+    expr : Expr
+        A SymPy expression to be converted.
+    assign_to : optional
+        When given, the argument is used for naming the variable or variables
+        to which the expression is assigned. Can be a string, ``Symbol``,
+        ``MatrixSymbol`` or ``Indexed`` type object. In cases where ``expr``
+        would be printed as an array, a list of string or ``Symbol`` objects
+        can also be passed.
+
+        This is helpful in case of line-wrapping, or for expressions that
+        generate multi-line statements.  It can also be used to spread an array-like
+        expression into multiple assignments.
+    use_operators: bool, optional
+        If set to False, then *,/,+,- operators will be replaced with functions
+        mul, add, and sub, which must be implemented by the user, e.g. for
+        implementing non-standard rings or emulated quad/octal precision.
+        [default=True]
+    glsl_types: bool, optional
+        Set this argument to ``False`` in order to avoid using the ``vec`` and ``mat``
+        types.  The printer will instead use arrays (or nested arrays).
+        [default=True]
+    mat_nested: bool, optional
+        GLSL version 4.3 and above support nested arrays (arrays of arrays).  Set this to ``True``
+        to render matrices as nested arrays.
+        [default=False]
+    mat_separator: str, optional
+        By default, matrices are rendered with newlines using this separator,
+        making them easier to read, but less compact.  By removing the newline
+        this option can be used to make them more vertically compact.
+        [default=',\n']
+    mat_transpose: bool, optional
+        GLSL's matrix multiplication implementation assumes column-major indexing.
+        By default, this printer ignores that convention. Setting this option to
+        ``True`` transposes all matrix output.
+        [default=False]
+    array_type: str, optional
+        The GLSL array constructor type.
+        [default='float']
+    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 glsl_code, symbols, Rational, sin, ceiling, Abs
+    >>> x, tau = symbols("x, tau")
+    >>> glsl_code((2*tau)**Rational(7, 2))
+    '8*sqrt(2)*pow(tau, 3.5)'
+    >>> glsl_code(sin(x), assign_to="float y")
+    'float y = sin(x);'
+
+    Various GLSL types are supported:
+    >>> from sympy import Matrix, glsl_code
+    >>> glsl_code(Matrix([1,2,3]))
+    'vec3(1, 2, 3)'
+
+    >>> glsl_code(Matrix([[1, 2],[3, 4]]))
+    'mat2(1, 2, 3, 4)'
+
+    Pass ``mat_transpose = True`` to switch to column-major indexing:
+    >>> glsl_code(Matrix([[1, 2],[3, 4]]), mat_transpose = True)
+    'mat2(1, 3, 2, 4)'
+
+    By default, larger matrices get collapsed into float arrays:
+    >>> print(glsl_code( Matrix([[1,2,3,4,5],[6,7,8,9,10]]) ))
+    float[10](
+       1, 2, 3, 4,  5,
+       6, 7, 8, 9, 10
+    ) /* a 2x5 matrix */
+
+    The type of array constructor used to print GLSL arrays can be controlled
+    via the ``array_type`` parameter:
+    >>> glsl_code(Matrix([1,2,3,4,5]), array_type='int')
+    'int[5](1, 2, 3, 4, 5)'
+
+    Passing a list of strings or ``symbols`` to the ``assign_to`` parameter will yield
+    a multi-line assignment for each item in an array-like expression:
+    >>> x_struct_members = symbols('x.a x.b x.c x.d')
+    >>> print(glsl_code(Matrix([1,2,3,4]), assign_to=x_struct_members))
+    x.a = 1;
+    x.b = 2;
+    x.c = 3;
+    x.d = 4;
+
+    This could be useful in cases where it's desirable to modify members of a
+    GLSL ``Struct``.  It could also be used to spread items from an array-like
+    expression into various miscellaneous assignments:
+    >>> misc_assignments = ('x[0]', 'x[1]', 'float y', 'float z')
+    >>> print(glsl_code(Matrix([1,2,3,4]), assign_to=misc_assignments))
+    x[0] = 1;
+    x[1] = 2;
+    float y = 3;
+    float z = 4;
+
+    Passing ``mat_nested = True`` instead prints out nested float arrays, which are
+    supported in GLSL 4.3 and above.
+    >>> mat = Matrix([
+    ... [ 0,  1,  2],
+    ... [ 3,  4,  5],
+    ... [ 6,  7,  8],
+    ... [ 9, 10, 11],
+    ... [12, 13, 14]])
+    >>> print(glsl_code( mat, mat_nested = True ))
+    float[5][3](
+       float[]( 0,  1,  2),
+       float[]( 3,  4,  5),
+       float[]( 6,  7,  8),
+       float[]( 9, 10, 11),
+       float[](12, 13, 14)
+    )
+
+
+
+    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")]
+    ... }
+    >>> glsl_code(Abs(x) + ceiling(x), user_functions=custom_functions)
+    'fabs(x) + CEIL(x)'
+
+    If further control is needed, addition, subtraction, multiplication and
+    division operators can be replaced with ``add``, ``sub``, and ``mul``
+    functions.  This is done by passing ``use_operators = False``:
+
+    >>> x,y,z = symbols('x,y,z')
+    >>> glsl_code(x*(y+z), use_operators = False)
+    'mul(x, add(y, z))'
+    >>> glsl_code(x*(y+z*(x-y)**z), use_operators = False)
+    'mul(x, add(y, mul(z, pow(sub(x, y), z))))'
+
+    ``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(glsl_code(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]))
+    >>> glsl_code(e.rhs, assign_to=e.lhs, contract=False)
+    'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);'
+
+    >>> from sympy import Matrix, MatrixSymbol
+    >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)])
+    >>> A = MatrixSymbol('A', 3, 1)
+    >>> print(glsl_code(mat, A))
+    A[0][0] = pow(x, 2.0);
+    if (x > 0) {
+       A[1][0] = x + 1;
+    }
+    else {
+       A[1][0] = x;
+    }
+    A[2][0] = sin(x);
+    """
+    return GLSLPrinter(settings).doprint(expr,assign_to)
+
+def print_glsl(expr, **settings):
+    """Prints the GLSL representation of the given expression.
+
+       See GLSLPrinter init function for settings.
+    """
+    print(glsl_code(expr, **settings))

env-llmeval/lib/python3.10/site-packages/sympy/printing/gtk.py

@@ -0,0 +1,16 @@
+from sympy.printing.mathml import mathml
+from sympy.utilities.mathml import c2p
+import tempfile
+import subprocess
+
+
+def print_gtk(x, start_viewer=True):
+    """Print to Gtkmathview, a gtk widget capable of rendering MathML.
+
+    Needs libgtkmathview-bin"""
+    with tempfile.NamedTemporaryFile('w') as file:
+        file.write(c2p(mathml(x), simple=True))
+        file.flush()
+
+        if start_viewer:
+            subprocess.check_call(('mathmlviewer', file.name))

env-llmeval/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))

env-llmeval/lib/python3.10/site-packages/sympy/printing/julia.py

@@ -0,0 +1,658 @@
+"""
+Julia code printer
+
+The `JuliaCodePrinter` converts SymPy expressions into Julia expressions.
+
+A complete code generator, which uses `julia_code` extensively, can be found
+in `sympy.utilities.codegen`.  The `codegen` module can be used to generate
+complete source code files.
+
+"""
+
+from __future__ import annotations
+from typing import Any
+
+from sympy.core import Mul, Pow, S, Rational
+from sympy.core.mul import _keep_coeff
+from sympy.core.numbers import equal_valued
+from sympy.printing.codeprinter import CodePrinter
+from sympy.printing.precedence import precedence, PRECEDENCE
+from re import search
+
+# List of known functions.  First, those that have the same name in
+# SymPy and Julia. This is almost certainly incomplete!
+known_fcns_src1 = ["sin", "cos", "tan", "cot", "sec", "csc",
+                   "asin", "acos", "atan", "acot", "asec", "acsc",
+                   "sinh", "cosh", "tanh", "coth", "sech", "csch",
+                   "asinh", "acosh", "atanh", "acoth", "asech", "acsch",
+                   "sinc", "atan2", "sign", "floor", "log", "exp",
+                   "cbrt", "sqrt", "erf", "erfc", "erfi",
+                   "factorial", "gamma", "digamma", "trigamma",
+                   "polygamma", "beta",
+                   "airyai", "airyaiprime", "airybi", "airybiprime",
+                   "besselj", "bessely", "besseli", "besselk",
+                   "erfinv", "erfcinv"]
+# These functions have different names ("SymPy": "Julia"), more
+# generally a mapping to (argument_conditions, julia_function).
+known_fcns_src2 = {
+    "Abs": "abs",
+    "ceiling": "ceil",
+    "conjugate": "conj",
+    "hankel1": "hankelh1",
+    "hankel2": "hankelh2",
+    "im": "imag",
+    "re": "real"
+}
+
+
+class JuliaCodePrinter(CodePrinter):
+    """
+    A printer to convert expressions to strings of Julia code.
+    """
+    printmethod = "_julia"
+    language = "Julia"
+
+    _operators = {
+        'and': '&&',
+        'or': '||',
+        'not': '!',
+    }
+
+    _default_settings: dict[str, Any] = {
+        'order': None,
+        'full_prec': 'auto',
+        'precision': 17,
+        'user_functions': {},
+        'human': True,
+        'allow_unknown_functions': False,
+        'contract': True,
+        'inline': True,
+    }
+    # Note: contract is for expressing tensors as loops (if True), or just
+    # assignment (if False).  FIXME: this should be looked a more carefully
+    # for Julia.
+
+    def __init__(self, settings={}):
+        super().__init__(settings)
+        self.known_functions = dict(zip(known_fcns_src1, known_fcns_src1))
+        self.known_functions.update(dict(known_fcns_src2))
+        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 "const {} = {}".format(name, value)
+
+
+    def _format_code(self, lines):
+        return self.indent_code(lines)
+
+
+    def _traverse_matrix_indices(self, mat):
+        # Julia uses Fortran order (column-major)
+        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:
+            # Julia 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("for %s = %s:%s" % (var, start, stop))
+            close_lines.append("end")
+        return open_lines, close_lines
+
+
+    def _print_Mul(self, expr):
+        # print complex numbers nicely in Julia
+        if (expr.is_number and expr.is_imaginary and
+                expr.as_coeff_Mul()[0].is_integer):
+            return "%sim" % self._print(-S.ImaginaryUnit*expr)
+
+        # cribbed from str.py
+        prec = precedence(expr)
+
+        c, e = expr.as_coeff_Mul()
+        if c < 0:
+            expr = _keep_coeff(-c, e)
+            sign = "-"
+        else:
+            sign = ""
+
+        a = []  # items in the numerator
+        b = []  # items that are in the denominator (if any)
+
+        pow_paren = []  # Will collect all pow with more than one base element and exp = -1
+
+        if self.order not in ('old', 'none'):
+            args = expr.as_ordered_factors()
+        else:
+            # use make_args in case expr was something like -x -> x
+            args = Mul.make_args(expr)
+
+        # Gather args for numerator/denominator
+        for item in args:
+            if (item.is_commutative and item.is_Pow and item.exp.is_Rational
+                    and item.exp.is_negative):
+                if item.exp != -1:
+                    b.append(Pow(item.base, -item.exp, evaluate=False))
+                else:
+                    if len(item.args[0].args) != 1 and isinstance(item.base, Mul):   # To avoid situations like #14160
+                        pow_paren.append(item)
+                    b.append(Pow(item.base, -item.exp))
+            elif item.is_Rational and item is not S.Infinity and item.p == 1:
+                # Save the Rational type in julia Unless the numerator is 1.
+                # For example:
+                # julia_code(Rational(3, 7)*x) --> (3 // 7) * x
+                # julia_code(x/3) --> x / 3 but not x * (1 // 3)
+                b.append(Rational(item.q))
+            else:
+                a.append(item)
+
+        a = a or [S.One]
+
+        a_str = [self.parenthesize(x, prec) for x in a]
+        b_str = [self.parenthesize(x, prec) for x in b]
+
+        # To parenthesize Pow with exp = -1 and having more than one Symbol
+        for item in pow_paren:
+            if item.base in b:
+                b_str[b.index(item.base)] = "(%s)" % b_str[b.index(item.base)]
+
+        # from here it differs from str.py to deal with "*" and ".*"
+        def multjoin(a, a_str):
+            # here we probably are assuming the constants will come first
+            r = a_str[0]
+            for i in range(1, len(a)):
+                mulsym = '*' if a[i-1].is_number else '.*'
+                r = "%s %s %s" % (r, mulsym, a_str[i])
+            return r
+
+        if not b:
+            return sign + multjoin(a, a_str)
+        elif len(b) == 1:
+            divsym = '/' if b[0].is_number else './'
+            return "%s %s %s" % (sign+multjoin(a, a_str), divsym, b_str[0])
+        else:
+            divsym = '/' if all(bi.is_number for bi in b) else './'
+            return "%s %s (%s)" % (sign + multjoin(a, a_str), divsym, multjoin(b, b_str))
+
+    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_Pow(self, expr):
+        powsymbol = '^' if all(x.is_number for x in expr.args) else '.^'
+
+        PREC = precedence(expr)
+
+        if equal_valued(expr.exp, 0.5):
+            return "sqrt(%s)" % self._print(expr.base)
+
+        if expr.is_commutative:
+            if equal_valued(expr.exp, -0.5):
+                sym = '/' if expr.base.is_number else './'
+                return "1 %s sqrt(%s)" % (sym, self._print(expr.base))
+            if equal_valued(expr.exp, -1):
+                sym = '/' if expr.base.is_number else './'
+                return  "1 %s %s" % (sym, self.parenthesize(expr.base, PREC))
+
+        return '%s %s %s' % (self.parenthesize(expr.base, PREC), powsymbol,
+                           self.parenthesize(expr.exp, PREC))
+
+
+    def _print_MatPow(self, expr):
+        PREC = precedence(expr)
+        return '%s ^ %s' % (self.parenthesize(expr.base, PREC),
+                          self.parenthesize(expr.exp, PREC))
+
+
+    def _print_Pi(self, expr):
+        if self._settings["inline"]:
+            return "pi"
+        else:
+            return super()._print_NumberSymbol(expr)
+
+
+    def _print_ImaginaryUnit(self, expr):
+        return "im"
+
+
+    def _print_Exp1(self, expr):
+        if self._settings["inline"]:
+            return "e"
+        else:
+            return super()._print_NumberSymbol(expr)
+
+
+    def _print_EulerGamma(self, expr):
+        if self._settings["inline"]:
+            return "eulergamma"
+        else:
+            return super()._print_NumberSymbol(expr)
+
+
+    def _print_Catalan(self, expr):
+        if self._settings["inline"]:
+            return "catalan"
+        else:
+            return super()._print_NumberSymbol(expr)
+
+
+    def _print_GoldenRatio(self, expr):
+        if self._settings["inline"]:
+            return "golden"
+        else:
+            return super()._print_NumberSymbol(expr)
+
+
+    def _print_Assignment(self, expr):
+        from sympy.codegen.ast import Assignment
+        from sympy.functions.elementary.piecewise import Piecewise
+        from sympy.tensor.indexed import IndexedBase
+        # Copied from codeprinter, but remove special MatrixSymbol treatment
+        lhs = expr.lhs
+        rhs = expr.rhs
+        # We special case assignments that take multiple lines
+        if not self._settings["inline"] and isinstance(expr.rhs, Piecewise):
+            # Here we modify Piecewise so each expression is now
+            # an Assignment, and then continue on the print.
+            expressions = []
+            conditions = []
+            for (e, c) in rhs.args:
+                expressions.append(Assignment(lhs, e))
+                conditions.append(c)
+            temp = Piecewise(*zip(expressions, conditions))
+            return self._print(temp)
+        if self._settings["contract"] and (lhs.has(IndexedBase) or
+                rhs.has(IndexedBase)):
+            # Here we check if there is looping to be done, and if so
+            # print the required loops.
+            return self._doprint_loops(rhs, lhs)
+        else:
+            lhs_code = self._print(lhs)
+            rhs_code = self._print(rhs)
+            return self._get_statement("%s = %s" % (lhs_code, rhs_code))
+
+
+    def _print_Infinity(self, expr):
+        return 'Inf'
+
+
+    def _print_NegativeInfinity(self, expr):
+        return '-Inf'
+
+
+    def _print_NaN(self, expr):
+        return 'NaN'
+
+
+    def _print_list(self, expr):
+        return 'Any[' + ', '.join(self._print(a) for a in expr) + ']'
+
+
+    def _print_tuple(self, expr):
+        if len(expr) == 1:
+            return "(%s,)" % self._print(expr[0])
+        else:
+            return "(%s)" % self.stringify(expr, ", ")
+    _print_Tuple = _print_tuple
+
+
+    def _print_BooleanTrue(self, expr):
+        return "true"
+
+
+    def _print_BooleanFalse(self, expr):
+        return "false"
+
+
+    def _print_bool(self, expr):
+        return str(expr).lower()
+
+
+    # Could generate quadrature code for definite Integrals?
+    #_print_Integral = _print_not_supported
+
+
+    def _print_MatrixBase(self, A):
+        # Handle zero dimensions:
+        if S.Zero in A.shape:
+            return 'zeros(%s, %s)' % (A.rows, A.cols)
+        elif (A.rows, A.cols) == (1, 1):
+            return "[%s]" % A[0, 0]
+        elif A.rows == 1:
+            return "[%s]" % A.table(self, rowstart='', rowend='', colsep=' ')
+        elif A.cols == 1:
+            # note .table would unnecessarily equispace the rows
+            return "[%s]" % ", ".join([self._print(a) for a in A])
+        return "[%s]" % A.table(self, rowstart='', rowend='',
+                                rowsep=';\n', colsep=' ')
+
+
+    def _print_SparseRepMatrix(self, A):
+        from sympy.matrices import Matrix
+        L = A.col_list();
+        # make row vectors of the indices and entries
+        I = Matrix([k[0] + 1 for k in L])
+        J = Matrix([k[1] + 1 for k in L])
+        AIJ = Matrix([k[2] for k in L])
+        return "sparse(%s, %s, %s, %s, %s)" % (self._print(I), self._print(J),
+                                            self._print(AIJ), A.rows, A.cols)
+
+
+    def _print_MatrixElement(self, expr):
+        return self.parenthesize(expr.parent, PRECEDENCE["Atom"], strict=True) \
+            + '[%s,%s]' % (expr.i + 1, expr.j + 1)
+
+
+    def _print_MatrixSlice(self, expr):
+        def strslice(x, lim):
+            l = x[0] + 1
+            h = x[1]
+            step = x[2]
+            lstr = self._print(l)
+            hstr = 'end' if h == lim else self._print(h)
+            if step == 1:
+                if l == 1 and h == lim:
+                    return ':'
+                if l == h:
+                    return lstr
+                else:
+                    return lstr + ':' + hstr
+            else:
+                return ':'.join((lstr, self._print(step), hstr))
+        return (self._print(expr.parent) + '[' +
+                strslice(expr.rowslice, expr.parent.shape[0]) + ',' +
+                strslice(expr.colslice, expr.parent.shape[1]) + ']')
+
+
+    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_Identity(self, expr):
+        return "eye(%s)" % self._print(expr.shape[0])
+
+    def _print_HadamardProduct(self, expr):
+        return ' .* '.join([self.parenthesize(arg, precedence(expr))
+                          for arg in expr.args])
+
+    def _print_HadamardPower(self, expr):
+        PREC = precedence(expr)
+        return '.**'.join([
+            self.parenthesize(expr.base, PREC),
+            self.parenthesize(expr.exp, PREC)
+            ])
+
+    def _print_Rational(self, expr):
+        if expr.q == 1:
+            return str(expr.p)
+        return "%s // %s" % (expr.p, expr.q)
+
+    # Note: as of 2022, Julia doesn't have spherical Bessel functions
+    def _print_jn(self, expr):
+        from sympy.functions import sqrt, besselj
+        x = expr.argument
+        expr2 = sqrt(S.Pi/(2*x))*besselj(expr.order + S.Half, x)
+        return self._print(expr2)
+
+
+    def _print_yn(self, expr):
+        from sympy.functions import sqrt, bessely
+        x = expr.argument
+        expr2 = sqrt(S.Pi/(2*x))*bessely(expr.order + S.Half, x)
+        return self._print(expr2)
+
+
+    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 self._settings["inline"]:
+            # Express each (cond, expr) pair in a nested Horner form:
+            #   (condition) .* (expr) + (not cond) .* (<others>)
+            # Expressions that result in multiple statements won't work here.
+            ecpairs = ["({}) ? ({}) :".format
+                       (self._print(c), self._print(e))
+                       for e, c in expr.args[:-1]]
+            elast = " (%s)" % self._print(expr.args[-1].expr)
+            pw = "\n".join(ecpairs) + elast
+            # Note: current need these outer brackets for 2*pw.  Would be
+            # nicer to teach parenthesize() to do this for us when needed!
+            return "(" + pw + ")"
+        else:
+            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("elseif (%s)" % self._print(c))
+                code0 = self._print(e)
+                lines.append(code0)
+                if i == len(expr.args) - 1:
+                    lines.append("end")
+            return "\n".join(lines)
+
+    def _print_MatMul(self, expr):
+        c, m = expr.as_coeff_mmul()
+
+        sign = ""
+        if c.is_number:
+            re, im = c.as_real_imag()
+            if im.is_zero and re.is_negative:
+                expr = _keep_coeff(-c, m)
+                sign = "-"
+            elif re.is_zero and im.is_negative:
+                expr = _keep_coeff(-c, m)
+                sign = "-"
+
+        return sign + ' * '.join(
+            (self.parenthesize(arg, precedence(expr)) for arg in expr.args)
+        )
+
+
+    def indent_code(self, code):
+        """Accepts a string of code or a list of code lines"""
+
+        # code mostly copied from ccode
+        if isinstance(code, str):
+            code_lines = self.indent_code(code.splitlines(True))
+            return ''.join(code_lines)
+
+        tab = "    "
+        inc_regex = ('^function ', '^if ', '^elseif ', '^else$', '^for ')
+        dec_regex = ('^end$', '^elseif ', '^else$')
+
+        # pre-strip left-space from the code
+        code = [ line.lstrip(' \t') for line in code ]
+
+        increase = [ int(any(search(re, line) for re in inc_regex))
+                     for line in code ]
+        decrease = [ int(any(search(re, line) for re in dec_regex))
+                     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 julia_code(expr, assign_to=None, **settings):
+    r"""Converts `expr` to a string of Julia 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].
+
+    Examples
+    ========
+
+    >>> from sympy import julia_code, symbols, sin, pi
+    >>> x = symbols('x')
+    >>> julia_code(sin(x).series(x).removeO())
+    'x .^ 5 / 120 - x .^ 3 / 6 + x'
+
+    >>> from sympy import Rational, ceiling
+    >>> x, y, tau = symbols("x, y, tau")
+    >>> julia_code((2*tau)**Rational(7, 2))
+    '8 * sqrt(2) * tau .^ (7 // 2)'
+
+    Note that element-wise (Hadamard) operations are used by default between
+    symbols.  This is because its possible in Julia to write "vectorized"
+    code.  It is harmless if the values are scalars.
+
+    >>> julia_code(sin(pi*x*y), assign_to="s")
+    's = sin(pi * x .* y)'
+
+    If you need a matrix product "*" or matrix power "^", you can specify the
+    symbol as a ``MatrixSymbol``.
+
+    >>> from sympy import Symbol, MatrixSymbol
+    >>> n = Symbol('n', integer=True, positive=True)
+    >>> A = MatrixSymbol('A', n, n)
+    >>> julia_code(3*pi*A**3)
+    '(3 * pi) * A ^ 3'
+
+    This class uses several rules to decide which symbol to use a product.
+    Pure numbers use "*", Symbols use ".*" and MatrixSymbols use "*".
+    A HadamardProduct can be used to specify componentwise multiplication ".*"
+    of two MatrixSymbols.  There is currently there is no easy way to specify
+    scalar symbols, so sometimes the code might have some minor cosmetic
+    issues.  For example, suppose x and y are scalars and A is a Matrix, then
+    while a human programmer might write "(x^2*y)*A^3", we generate:
+
+    >>> julia_code(x**2*y*A**3)
+    '(x .^ 2 .* y) * A ^ 3'
+
+    Matrices are supported using Julia inline notation.  When using
+    ``assign_to`` with matrices, the name can be specified either as a string
+    or as a ``MatrixSymbol``.  The dimensions must align in the latter case.
+
+    >>> from sympy import Matrix, MatrixSymbol
+    >>> mat = Matrix([[x**2, sin(x), ceiling(x)]])
+    >>> julia_code(mat, assign_to='A')
+    'A = [x .^ 2 sin(x) ceil(x)]'
+
+    ``Piecewise`` expressions are implemented with logical masking by default.
+    Alternatively, you can pass "inline=False" to use if-else conditionals.
+    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
+    >>> pw = Piecewise((x + 1, x > 0), (x, True))
+    >>> julia_code(pw, assign_to=tau)
+    'tau = ((x > 0) ? (x + 1) : (x))'
+
+    Note that any expression that can be generated normally can also exist
+    inside a Matrix:
+
+    >>> mat = Matrix([[x**2, pw, sin(x)]])
+    >>> julia_code(mat, assign_to='A')
+    'A = [x .^ 2 ((x > 0) ? (x + 1) : (x)) 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,
+    cfunction_string)].  This can be used to call a custom Julia function.
+
+    >>> from sympy import Function
+    >>> f = Function('f')
+    >>> g = Function('g')
+    >>> custom_functions = {
+    ...   "f": "existing_julia_fcn",
+    ...   "g": [(lambda x: x.is_Matrix, "my_mat_fcn"),
+    ...         (lambda x: not x.is_Matrix, "my_fcn")]
+    ... }
+    >>> mat = Matrix([[1, x]])
+    >>> julia_code(f(x) + g(x) + g(mat), user_functions=custom_functions)
+    'existing_julia_fcn(x) + my_fcn(x) + my_mat_fcn([1 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]))
+    >>> julia_code(e.rhs, assign_to=e.lhs, contract=False)
+    'Dy[i] = (y[i + 1] - y[i]) ./ (t[i + 1] - t[i])'
+    """
+    return JuliaCodePrinter(settings).doprint(expr, assign_to)
+
+
+def print_julia_code(expr, **settings):
+    """Prints the Julia representation of the given expression.
+
+    See `julia_code` for the meaning of the optional arguments.
+    """
+    print(julia_code(expr, **settings))

env-llmeval/lib/python3.10/site-packages/sympy/printing/lambdarepr.py

@@ -0,0 +1,251 @@
+from .pycode import (
+    PythonCodePrinter,
+    MpmathPrinter,
+)
+from .numpy import NumPyPrinter  # NumPyPrinter is imported for backward compatibility
+from sympy.core.sorting import default_sort_key
+
+
+__all__ = [
+    'PythonCodePrinter',
+    'MpmathPrinter',  # MpmathPrinter is published for backward compatibility
+    'NumPyPrinter',
+    'LambdaPrinter',
+    'NumPyPrinter',
+    'IntervalPrinter',
+    'lambdarepr',
+]
+
+
+class LambdaPrinter(PythonCodePrinter):
+    """
+    This printer converts expressions into strings that can be used by
+    lambdify.
+    """
+    printmethod = "_lambdacode"
+
+
+    def _print_And(self, expr):
+        result = ['(']
+        for arg in sorted(expr.args, key=default_sort_key):
+            result.extend(['(', self._print(arg), ')'])
+            result.append(' and ')
+        result = result[:-1]
+        result.append(')')
+        return ''.join(result)
+
+    def _print_Or(self, expr):
+        result = ['(']
+        for arg in sorted(expr.args, key=default_sort_key):
+            result.extend(['(', self._print(arg), ')'])
+            result.append(' or ')
+        result = result[:-1]
+        result.append(')')
+        return ''.join(result)
+
+    def _print_Not(self, expr):
+        result = ['(', 'not (', self._print(expr.args[0]), '))']
+        return ''.join(result)
+
+    def _print_BooleanTrue(self, expr):
+        return "True"
+
+    def _print_BooleanFalse(self, expr):
+        return "False"
+
+    def _print_ITE(self, expr):
+        result = [
+            '((', self._print(expr.args[1]),
+            ') if (', self._print(expr.args[0]),
+            ') else (', self._print(expr.args[2]), '))'
+        ]
+        return ''.join(result)
+
+    def _print_NumberSymbol(self, expr):
+        return str(expr)
+
+    def _print_Pow(self, expr, **kwargs):
+        # XXX Temporary workaround. Should Python math printer be
+        # isolated from PythonCodePrinter?
+        return super(PythonCodePrinter, self)._print_Pow(expr, **kwargs)
+
+
+# numexpr works by altering the string passed to numexpr.evaluate
+# rather than by populating a namespace.  Thus a special printer...
+class NumExprPrinter(LambdaPrinter):
+    # key, value pairs correspond to SymPy name and numexpr name
+    # functions not appearing in this dict will raise a TypeError
+    printmethod = "_numexprcode"
+
+    _numexpr_functions = {
+        'sin' : 'sin',
+        'cos' : 'cos',
+        'tan' : 'tan',
+        'asin': 'arcsin',
+        'acos': 'arccos',
+        'atan': 'arctan',
+        'atan2' : 'arctan2',
+        'sinh' : 'sinh',
+        'cosh' : 'cosh',
+        'tanh' : 'tanh',
+        'asinh': 'arcsinh',
+        'acosh': 'arccosh',
+        'atanh': 'arctanh',
+        'ln' : 'log',
+        'log': 'log',
+        'exp': 'exp',
+        'sqrt' : 'sqrt',
+        'Abs' : 'abs',
+        'conjugate' : 'conj',
+        'im' : 'imag',
+        're' : 'real',
+        'where' : 'where',
+        'complex' : 'complex',
+        'contains' : 'contains',
+    }
+
+    module = 'numexpr'
+
+    def _print_ImaginaryUnit(self, expr):
+        return '1j'
+
+    def _print_seq(self, seq, delimiter=', '):
+        # simplified _print_seq taken from pretty.py
+        s = [self._print(item) for item in seq]
+        if s:
+            return delimiter.join(s)
+        else:
+            return ""
+
+    def _print_Function(self, e):
+        func_name = e.func.__name__
+
+        nstr = self._numexpr_functions.get(func_name, None)
+        if nstr is None:
+            # check for implemented_function
+            if hasattr(e, '_imp_'):
+                return "(%s)" % self._print(e._imp_(*e.args))
+            else:
+                raise TypeError("numexpr does not support function '%s'" %
+                                func_name)
+        return "%s(%s)" % (nstr, self._print_seq(e.args))
+
+    def _print_Piecewise(self, expr):
+        "Piecewise function printer"
+        exprs = [self._print(arg.expr) for arg in expr.args]
+        conds = [self._print(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.
+        ans = []
+        parenthesis_count = 0
+        is_last_cond_True = False
+        for cond, expr in zip(conds, exprs):
+            if cond == 'True':
+                ans.append(expr)
+                is_last_cond_True = True
+                break
+            else:
+                ans.append('where(%s, %s, ' % (cond, expr))
+                parenthesis_count += 1
+        if not is_last_cond_True:
+            # See https://github.com/pydata/numexpr/issues/298
+            #
+            # simplest way to put a nan but raises
+            # 'RuntimeWarning: invalid value encountered in log'
+            #
+            # There are other ways to do this such as
+            #
+            #   >>> import numexpr as ne
+            #   >>> nan = float('nan')
+            #   >>> ne.evaluate('where(x < 0, -1, nan)', {'x': [-1, 2, 3], 'nan':nan})
+            #   array([-1., nan, nan])
+            #
+            # That needs to be handled in the lambdified function though rather
+            # than here in the printer.
+            ans.append('log(-1)')
+        return ''.join(ans) + ')' * parenthesis_count
+
+    def _print_ITE(self, expr):
+        from sympy.functions.elementary.piecewise import Piecewise
+        return self._print(expr.rewrite(Piecewise))
+
+    def blacklisted(self, expr):
+        raise TypeError("numexpr cannot be used with %s" %
+                        expr.__class__.__name__)
+
+    # blacklist all Matrix printing
+    _print_SparseRepMatrix = \
+    _print_MutableSparseMatrix = \
+    _print_ImmutableSparseMatrix = \
+    _print_Matrix = \
+    _print_DenseMatrix = \
+    _print_MutableDenseMatrix = \
+    _print_ImmutableMatrix = \
+    _print_ImmutableDenseMatrix = \
+    blacklisted
+    # blacklist some Python expressions
+    _print_list = \
+    _print_tuple = \
+    _print_Tuple = \
+    _print_dict = \
+    _print_Dict = \
+    blacklisted
+
+    def _print_NumExprEvaluate(self, expr):
+        evaluate = self._module_format(self.module +".evaluate")
+        return "%s('%s', truediv=True)" % (evaluate, self._print(expr.expr))
+
+    def doprint(self, expr):
+        from sympy.codegen.ast import CodegenAST
+        from sympy.codegen.pynodes import NumExprEvaluate
+        if not isinstance(expr, CodegenAST):
+            expr = NumExprEvaluate(expr)
+        return super().doprint(expr)
+
+    def _print_Return(self, expr):
+        from sympy.codegen.pynodes import NumExprEvaluate
+        r, = expr.args
+        if not isinstance(r, NumExprEvaluate):
+            expr = expr.func(NumExprEvaluate(r))
+        return super()._print_Return(expr)
+
+    def _print_Assignment(self, expr):
+        from sympy.codegen.pynodes import NumExprEvaluate
+        lhs, rhs, *args = expr.args
+        if not isinstance(rhs, NumExprEvaluate):
+            expr = expr.func(lhs, NumExprEvaluate(rhs), *args)
+        return super()._print_Assignment(expr)
+
+    def _print_CodeBlock(self, expr):
+        from sympy.codegen.ast import CodegenAST
+        from sympy.codegen.pynodes import NumExprEvaluate
+        args = [ arg if isinstance(arg, CodegenAST) else NumExprEvaluate(arg) for arg in expr.args ]
+        return super()._print_CodeBlock(self, expr.func(*args))
+
+
+class IntervalPrinter(MpmathPrinter, LambdaPrinter):
+    """Use ``lambda`` printer but print numbers as ``mpi`` intervals. """
+
+    def _print_Integer(self, expr):
+        return "mpi('%s')" % super(PythonCodePrinter, self)._print_Integer(expr)
+
+    def _print_Rational(self, expr):
+        return "mpi('%s')" % super(PythonCodePrinter, self)._print_Rational(expr)
+
+    def _print_Half(self, expr):
+        return "mpi('%s')" % super(PythonCodePrinter, self)._print_Rational(expr)
+
+    def _print_Pow(self, expr):
+        return super(MpmathPrinter, self)._print_Pow(expr, rational=True)
+
+
+for k in NumExprPrinter._numexpr_functions:
+    setattr(NumExprPrinter, '_print_%s' % k, NumExprPrinter._print_Function)
+
+def lambdarepr(expr, **settings):
+    """
+    Returns a string usable for lambdifying.
+    """
+    return LambdaPrinter(settings).doprint(expr)

env-llmeval/lib/python3.10/site-packages/sympy/printing/llvmjitcode.py

@@ -0,0 +1,489 @@
+'''
+Use llvmlite to create executable functions from SymPy expressions
+
+This module requires llvmlite (https://github.com/numba/llvmlite).
+'''
+
+import ctypes
+
+from sympy.external import import_module
+from sympy.printing.printer import Printer
+from sympy.core.singleton import S
+from sympy.tensor.indexed import IndexedBase
+from sympy.utilities.decorator import doctest_depends_on
+
+llvmlite = import_module('llvmlite')
+if llvmlite:
+    ll = import_module('llvmlite.ir').ir
+    llvm = import_module('llvmlite.binding').binding
+    llvm.initialize()
+    llvm.initialize_native_target()
+    llvm.initialize_native_asmprinter()
+
+
+__doctest_requires__ = {('llvm_callable'): ['llvmlite']}
+
+
+class LLVMJitPrinter(Printer):
+    '''Convert expressions to LLVM IR'''
+    def __init__(self, module, builder, fn, *args, **kwargs):
+        self.func_arg_map = kwargs.pop("func_arg_map", {})
+        if not llvmlite:
+            raise ImportError("llvmlite is required for LLVMJITPrinter")
+        super().__init__(*args, **kwargs)
+        self.fp_type = ll.DoubleType()
+        self.module = module
+        self.builder = builder
+        self.fn = fn
+        self.ext_fn = {}  # keep track of wrappers to external functions
+        self.tmp_var = {}
+
+    def _add_tmp_var(self, name, value):
+        self.tmp_var[name] = value
+
+    def _print_Number(self, n):
+        return ll.Constant(self.fp_type, float(n))
+
+    def _print_Integer(self, expr):
+        return ll.Constant(self.fp_type, float(expr.p))
+
+    def _print_Symbol(self, s):
+        val = self.tmp_var.get(s)
+        if not val:
+            # look up parameter with name s
+            val = self.func_arg_map.get(s)
+        if not val:
+            raise LookupError("Symbol not found: %s" % s)
+        return val
+
+    def _print_Pow(self, expr):
+        base0 = self._print(expr.base)
+        if expr.exp == S.NegativeOne:
+            return self.builder.fdiv(ll.Constant(self.fp_type, 1.0), base0)
+        if expr.exp == S.Half:
+            fn = self.ext_fn.get("sqrt")
+            if not fn:
+                fn_type = ll.FunctionType(self.fp_type, [self.fp_type])
+                fn = ll.Function(self.module, fn_type, "sqrt")
+                self.ext_fn["sqrt"] = fn
+            return self.builder.call(fn, [base0], "sqrt")
+        if expr.exp == 2:
+            return self.builder.fmul(base0, base0)
+
+        exp0 = self._print(expr.exp)
+        fn = self.ext_fn.get("pow")
+        if not fn:
+            fn_type = ll.FunctionType(self.fp_type, [self.fp_type, self.fp_type])
+            fn = ll.Function(self.module, fn_type, "pow")
+            self.ext_fn["pow"] = fn
+        return self.builder.call(fn, [base0, exp0], "pow")
+
+    def _print_Mul(self, expr):
+        nodes = [self._print(a) for a in expr.args]
+        e = nodes[0]
+        for node in nodes[1:]:
+            e = self.builder.fmul(e, node)
+        return e
+
+    def _print_Add(self, expr):
+        nodes = [self._print(a) for a in expr.args]
+        e = nodes[0]
+        for node in nodes[1:]:
+            e = self.builder.fadd(e, node)
+        return e
+
+    # TODO - assumes all called functions take one double precision argument.
+    #        Should have a list of math library functions to validate this.
+    def _print_Function(self, expr):
+        name = expr.func.__name__
+        e0 = self._print(expr.args[0])
+        fn = self.ext_fn.get(name)
+        if not fn:
+            fn_type = ll.FunctionType(self.fp_type, [self.fp_type])
+            fn = ll.Function(self.module, fn_type, name)
+            self.ext_fn[name] = fn
+        return self.builder.call(fn, [e0], name)
+
+    def emptyPrinter(self, expr):
+        raise TypeError("Unsupported type for LLVM JIT conversion: %s"
+                        % type(expr))
+
+
+# Used when parameters are passed by array.  Often used in callbacks to
+# handle a variable number of parameters.
+class LLVMJitCallbackPrinter(LLVMJitPrinter):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def _print_Indexed(self, expr):
+        array, idx = self.func_arg_map[expr.base]
+        offset = int(expr.indices[0].evalf())
+        array_ptr = self.builder.gep(array, [ll.Constant(ll.IntType(32), offset)])
+        fp_array_ptr = self.builder.bitcast(array_ptr, ll.PointerType(self.fp_type))
+        value = self.builder.load(fp_array_ptr)
+        return value
+
+    def _print_Symbol(self, s):
+        val = self.tmp_var.get(s)
+        if val:
+            return val
+
+        array, idx = self.func_arg_map.get(s, [None, 0])
+        if not array:
+            raise LookupError("Symbol not found: %s" % s)
+        array_ptr = self.builder.gep(array, [ll.Constant(ll.IntType(32), idx)])
+        fp_array_ptr = self.builder.bitcast(array_ptr,
+                                            ll.PointerType(self.fp_type))
+        value = self.builder.load(fp_array_ptr)
+        return value
+
+
+# ensure lifetime of the execution engine persists (else call to compiled
+#   function will seg fault)
+exe_engines = []
+
+# ensure names for generated functions are unique
+link_names = set()
+current_link_suffix = 0
+
+
+class LLVMJitCode:
+    def __init__(self, signature):
+        self.signature = signature
+        self.fp_type = ll.DoubleType()
+        self.module = ll.Module('mod1')
+        self.fn = None
+        self.llvm_arg_types = []
+        self.llvm_ret_type = self.fp_type
+        self.param_dict = {}  # map symbol name to LLVM function argument
+        self.link_name = ''
+
+    def _from_ctype(self, ctype):
+        if ctype == ctypes.c_int:
+            return ll.IntType(32)
+        if ctype == ctypes.c_double:
+            return self.fp_type
+        if ctype == ctypes.POINTER(ctypes.c_double):
+            return ll.PointerType(self.fp_type)
+        if ctype == ctypes.c_void_p:
+            return ll.PointerType(ll.IntType(32))
+        if ctype == ctypes.py_object:
+            return ll.PointerType(ll.IntType(32))
+
+        print("Unhandled ctype = %s" % str(ctype))
+
+    def _create_args(self, func_args):
+        """Create types for function arguments"""
+        self.llvm_ret_type = self._from_ctype(self.signature.ret_type)
+        self.llvm_arg_types = \
+            [self._from_ctype(a) for a in self.signature.arg_ctypes]
+
+    def _create_function_base(self):
+        """Create function with name and type signature"""
+        global link_names, current_link_suffix
+        default_link_name = 'jit_func'
+        current_link_suffix += 1
+        self.link_name = default_link_name + str(current_link_suffix)
+        link_names.add(self.link_name)
+
+        fn_type = ll.FunctionType(self.llvm_ret_type, self.llvm_arg_types)
+        self.fn = ll.Function(self.module, fn_type, name=self.link_name)
+
+    def _create_param_dict(self, func_args):
+        """Mapping of symbolic values to function arguments"""
+        for i, a in enumerate(func_args):
+            self.fn.args[i].name = str(a)
+            self.param_dict[a] = self.fn.args[i]
+
+    def _create_function(self, expr):
+        """Create function body and return LLVM IR"""
+        bb_entry = self.fn.append_basic_block('entry')
+        builder = ll.IRBuilder(bb_entry)
+
+        lj = LLVMJitPrinter(self.module, builder, self.fn,
+                            func_arg_map=self.param_dict)
+
+        ret = self._convert_expr(lj, expr)
+        lj.builder.ret(self._wrap_return(lj, ret))
+
+        strmod = str(self.module)
+        return strmod
+
+    def _wrap_return(self, lj, vals):
+        # Return a single double if there is one return value,
+        #  else return a tuple of doubles.
+
+        # Don't wrap return value in this case
+        if self.signature.ret_type == ctypes.c_double:
+            return vals[0]
+
+        # Use this instead of a real PyObject*
+        void_ptr = ll.PointerType(ll.IntType(32))
+
+        # Create a wrapped double: PyObject* PyFloat_FromDouble(double v)
+        wrap_type = ll.FunctionType(void_ptr, [self.fp_type])
+        wrap_fn = ll.Function(lj.module, wrap_type, "PyFloat_FromDouble")
+
+        wrapped_vals = [lj.builder.call(wrap_fn, [v]) for v in vals]
+        if len(vals) == 1:
+            final_val = wrapped_vals[0]
+        else:
+            # Create a tuple: PyObject* PyTuple_Pack(Py_ssize_t n, ...)
+
+            # This should be Py_ssize_t
+            tuple_arg_types = [ll.IntType(32)]
+
+            tuple_arg_types.extend([void_ptr]*len(vals))
+            tuple_type = ll.FunctionType(void_ptr, tuple_arg_types)
+            tuple_fn = ll.Function(lj.module, tuple_type, "PyTuple_Pack")
+
+            tuple_args = [ll.Constant(ll.IntType(32), len(wrapped_vals))]
+            tuple_args.extend(wrapped_vals)
+
+            final_val = lj.builder.call(tuple_fn, tuple_args)
+
+        return final_val
+
+    def _convert_expr(self, lj, expr):
+        try:
+            # Match CSE return data structure.
+            if len(expr) == 2:
+                tmp_exprs = expr[0]
+                final_exprs = expr[1]
+                if len(final_exprs) != 1 and self.signature.ret_type == ctypes.c_double:
+                    raise NotImplementedError("Return of multiple expressions not supported for this callback")
+                for name, e in tmp_exprs:
+                    val = lj._print(e)
+                    lj._add_tmp_var(name, val)
+        except TypeError:
+            final_exprs = [expr]
+
+        vals = [lj._print(e) for e in final_exprs]
+
+        return vals
+
+    def _compile_function(self, strmod):
+        global exe_engines
+        llmod = llvm.parse_assembly(strmod)
+
+        pmb = llvm.create_pass_manager_builder()
+        pmb.opt_level = 2
+        pass_manager = llvm.create_module_pass_manager()
+        pmb.populate(pass_manager)
+
+        pass_manager.run(llmod)
+
+        target_machine = \
+            llvm.Target.from_default_triple().create_target_machine()
+        exe_eng = llvm.create_mcjit_compiler(llmod, target_machine)
+        exe_eng.finalize_object()
+        exe_engines.append(exe_eng)
+
+        if False:
+            print("Assembly")
+            print(target_machine.emit_assembly(llmod))
+
+        fptr = exe_eng.get_function_address(self.link_name)
+
+        return fptr
+
+
+class LLVMJitCodeCallback(LLVMJitCode):
+    def __init__(self, signature):
+        super().__init__(signature)
+
+    def _create_param_dict(self, func_args):
+        for i, a in enumerate(func_args):
+            if isinstance(a, IndexedBase):
+                self.param_dict[a] = (self.fn.args[i], i)
+                self.fn.args[i].name = str(a)
+            else:
+                self.param_dict[a] = (self.fn.args[self.signature.input_arg],
+                                      i)
+
+    def _create_function(self, expr):
+        """Create function body and return LLVM IR"""
+        bb_entry = self.fn.append_basic_block('entry')
+        builder = ll.IRBuilder(bb_entry)
+
+        lj = LLVMJitCallbackPrinter(self.module, builder, self.fn,
+                                    func_arg_map=self.param_dict)
+
+        ret = self._convert_expr(lj, expr)
+
+        if self.signature.ret_arg:
+            output_fp_ptr = builder.bitcast(self.fn.args[self.signature.ret_arg],
+                                            ll.PointerType(self.fp_type))
+            for i, val in enumerate(ret):
+                index = ll.Constant(ll.IntType(32), i)
+                output_array_ptr = builder.gep(output_fp_ptr, [index])
+                builder.store(val, output_array_ptr)
+            builder.ret(ll.Constant(ll.IntType(32), 0))  # return success
+        else:
+            lj.builder.ret(self._wrap_return(lj, ret))
+
+        strmod = str(self.module)
+        return strmod
+
+
+class CodeSignature:
+    def __init__(self, ret_type):
+        self.ret_type = ret_type
+        self.arg_ctypes = []
+
+        # Input argument array element index
+        self.input_arg = 0
+
+        # For the case output value is referenced through a parameter rather
+        # than the return value
+        self.ret_arg = None
+
+
+def _llvm_jit_code(args, expr, signature, callback_type):
+    """Create a native code function from a SymPy expression"""
+    if callback_type is None:
+        jit = LLVMJitCode(signature)
+    else:
+        jit = LLVMJitCodeCallback(signature)
+
+    jit._create_args(args)
+    jit._create_function_base()
+    jit._create_param_dict(args)
+    strmod = jit._create_function(expr)
+    if False:
+        print("LLVM IR")
+        print(strmod)
+    fptr = jit._compile_function(strmod)
+    return fptr
+
+
+@doctest_depends_on(modules=('llvmlite', 'scipy'))
+def llvm_callable(args, expr, callback_type=None):
+    '''Compile function from a SymPy expression
+
+    Expressions are evaluated using double precision arithmetic.
+    Some single argument math functions (exp, sin, cos, etc.) are supported
+    in expressions.
+
+    Parameters
+    ==========
+
+    args : List of Symbol
+        Arguments to the generated function.  Usually the free symbols in
+        the expression.  Currently each one is assumed to convert to
+        a double precision scalar.
+    expr : Expr, or (Replacements, Expr) as returned from 'cse'
+        Expression to compile.
+    callback_type : string
+        Create function with signature appropriate to use as a callback.
+        Currently supported:
+           'scipy.integrate'
+           'scipy.integrate.test'
+           'cubature'
+
+    Returns
+    =======
+
+    Compiled function that can evaluate the expression.
+
+    Examples
+    ========
+
+    >>> import sympy.printing.llvmjitcode as jit
+    >>> from sympy.abc import a
+    >>> e = a*a + a + 1
+    >>> e1 = jit.llvm_callable([a], e)
+    >>> e.subs(a, 1.1)   # Evaluate via substitution
+    3.31000000000000
+    >>> e1(1.1)  # Evaluate using JIT-compiled code
+    3.3100000000000005
+
+
+    Callbacks for integration functions can be JIT compiled.
+    >>> import sympy.printing.llvmjitcode as jit
+    >>> from sympy.abc import a
+    >>> from sympy import integrate
+    >>> from scipy.integrate import quad
+    >>> e = a*a
+    >>> e1 = jit.llvm_callable([a], e, callback_type='scipy.integrate')
+    >>> integrate(e, (a, 0.0, 2.0))
+    2.66666666666667
+    >>> quad(e1, 0.0, 2.0)[0]
+    2.66666666666667
+
+    The 'cubature' callback is for the Python wrapper around the
+    cubature package ( https://github.com/saullocastro/cubature )
+    and ( http://ab-initio.mit.edu/wiki/index.php/Cubature )
+
+    There are two signatures for the SciPy integration callbacks.
+    The first ('scipy.integrate') is the function to be passed to the
+    integration routine, and will pass the signature checks.
+    The second ('scipy.integrate.test') is only useful for directly calling
+    the function using ctypes variables. It will not pass the signature checks
+    for scipy.integrate.
+
+    The return value from the cse module can also be compiled.  This
+    can improve the performance of the compiled function.  If multiple
+    expressions are given to cse, the compiled function returns a tuple.
+    The 'cubature' callback handles multiple expressions (set `fdim`
+    to match in the integration call.)
+    >>> import sympy.printing.llvmjitcode as jit
+    >>> from sympy import cse
+    >>> from sympy.abc import x,y
+    >>> e1 = x*x + y*y
+    >>> e2 = 4*(x*x + y*y) + 8.0
+    >>> after_cse = cse([e1,e2])
+    >>> after_cse
+    ([(x0, x**2), (x1, y**2)], [x0 + x1, 4*x0 + 4*x1 + 8.0])
+    >>> j1 = jit.llvm_callable([x,y], after_cse)
+    >>> j1(1.0, 2.0)
+    (5.0, 28.0)
+    '''
+
+    if not llvmlite:
+        raise ImportError("llvmlite is required for llvmjitcode")
+
+    signature = CodeSignature(ctypes.py_object)
+
+    arg_ctypes = []
+    if callback_type is None:
+        for _ in args:
+            arg_ctype = ctypes.c_double
+            arg_ctypes.append(arg_ctype)
+    elif callback_type in ('scipy.integrate', 'scipy.integrate.test'):
+        signature.ret_type = ctypes.c_double
+        arg_ctypes = [ctypes.c_int, ctypes.POINTER(ctypes.c_double)]
+        arg_ctypes_formal = [ctypes.c_int, ctypes.c_double]
+        signature.input_arg = 1
+    elif callback_type == 'cubature':
+        arg_ctypes = [ctypes.c_int,
+                      ctypes.POINTER(ctypes.c_double),
+                      ctypes.c_void_p,
+                      ctypes.c_int,
+                      ctypes.POINTER(ctypes.c_double)
+                      ]
+        signature.ret_type = ctypes.c_int
+        signature.input_arg = 1
+        signature.ret_arg = 4
+    else:
+        raise ValueError("Unknown callback type: %s" % callback_type)
+
+    signature.arg_ctypes = arg_ctypes
+
+    fptr = _llvm_jit_code(args, expr, signature, callback_type)
+
+    if callback_type and callback_type == 'scipy.integrate':
+        arg_ctypes = arg_ctypes_formal
+
+    # PYFUNCTYPE holds the GIL which is needed to prevent a segfault when
+    # calling PyFloat_FromDouble on Python 3.10. Probably it is better to use
+    # ctypes.c_double when returning a float rather than using ctypes.py_object
+    # and returning a PyFloat from inside the jitted function (i.e. let ctypes
+    # handle the conversion from double to PyFloat).
+    if signature.ret_type == ctypes.py_object:
+        FUNCTYPE = ctypes.PYFUNCTYPE
+    else:
+        FUNCTYPE = ctypes.CFUNCTYPE
+
+    cfunc = FUNCTYPE(signature.ret_type, *arg_ctypes)(fptr)
+    return cfunc

env-llmeval/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))

env-llmeval/lib/python3.10/site-packages/sympy/printing/mathematica.py

@@ -0,0 +1,354 @@
+"""
+Mathematica code printer
+"""
+
+from __future__ import annotations
+from typing import Any
+
+from sympy.core import Basic, Expr, Float
+from sympy.core.sorting import default_sort_key
+
+from sympy.printing.codeprinter import CodePrinter
+from sympy.printing.precedence import precedence
+
+# Used in MCodePrinter._print_Function(self)
+known_functions = {
+    "exp": [(lambda x: True, "Exp")],
+    "log": [(lambda x: True, "Log")],
+    "sin": [(lambda x: True, "Sin")],
+    "cos": [(lambda x: True, "Cos")],
+    "tan": [(lambda x: True, "Tan")],
+    "cot": [(lambda x: True, "Cot")],
+    "sec": [(lambda x: True, "Sec")],
+    "csc": [(lambda x: True, "Csc")],
+    "asin": [(lambda x: True, "ArcSin")],
+    "acos": [(lambda x: True, "ArcCos")],
+    "atan": [(lambda x: True, "ArcTan")],
+    "acot": [(lambda x: True, "ArcCot")],
+    "asec": [(lambda x: True, "ArcSec")],
+    "acsc": [(lambda x: True, "ArcCsc")],
+    "atan2": [(lambda *x: True, "ArcTan")],
+    "sinh": [(lambda x: True, "Sinh")],
+    "cosh": [(lambda x: True, "Cosh")],
+    "tanh": [(lambda x: True, "Tanh")],
+    "coth": [(lambda x: True, "Coth")],
+    "sech": [(lambda x: True, "Sech")],
+    "csch": [(lambda x: True, "Csch")],
+    "asinh": [(lambda x: True, "ArcSinh")],
+    "acosh": [(lambda x: True, "ArcCosh")],
+    "atanh": [(lambda x: True, "ArcTanh")],
+    "acoth": [(lambda x: True, "ArcCoth")],
+    "asech": [(lambda x: True, "ArcSech")],
+    "acsch": [(lambda x: True, "ArcCsch")],
+    "sinc": [(lambda x: True, "Sinc")],
+    "conjugate": [(lambda x: True, "Conjugate")],
+    "Max": [(lambda *x: True, "Max")],
+    "Min": [(lambda *x: True, "Min")],
+    "erf": [(lambda x: True, "Erf")],
+    "erf2": [(lambda *x: True, "Erf")],
+    "erfc": [(lambda x: True, "Erfc")],
+    "erfi": [(lambda x: True, "Erfi")],
+    "erfinv": [(lambda x: True, "InverseErf")],
+    "erfcinv": [(lambda x: True, "InverseErfc")],
+    "erf2inv": [(lambda *x: True, "InverseErf")],
+    "expint": [(lambda *x: True, "ExpIntegralE")],
+    "Ei": [(lambda x: True, "ExpIntegralEi")],
+    "fresnelc": [(lambda x: True, "FresnelC")],
+    "fresnels": [(lambda x: True, "FresnelS")],
+    "gamma": [(lambda x: True, "Gamma")],
+    "uppergamma": [(lambda *x: True, "Gamma")],
+    "polygamma": [(lambda *x: True, "PolyGamma")],
+    "loggamma": [(lambda x: True, "LogGamma")],
+    "beta": [(lambda *x: True, "Beta")],
+    "Ci": [(lambda x: True, "CosIntegral")],
+    "Si": [(lambda x: True, "SinIntegral")],
+    "Chi": [(lambda x: True, "CoshIntegral")],
+    "Shi": [(lambda x: True, "SinhIntegral")],
+    "li": [(lambda x: True, "LogIntegral")],
+    "factorial": [(lambda x: True, "Factorial")],
+    "factorial2": [(lambda x: True, "Factorial2")],
+    "subfactorial": [(lambda x: True, "Subfactorial")],
+    "catalan": [(lambda x: True, "CatalanNumber")],
+    "harmonic": [(lambda *x: True, "HarmonicNumber")],
+    "lucas": [(lambda x: True, "LucasL")],
+    "RisingFactorial": [(lambda *x: True, "Pochhammer")],
+    "FallingFactorial": [(lambda *x: True, "FactorialPower")],
+    "laguerre": [(lambda *x: True, "LaguerreL")],
+    "assoc_laguerre": [(lambda *x: True, "LaguerreL")],
+    "hermite": [(lambda *x: True, "HermiteH")],
+    "jacobi": [(lambda *x: True, "JacobiP")],
+    "gegenbauer": [(lambda *x: True, "GegenbauerC")],
+    "chebyshevt": [(lambda *x: True, "ChebyshevT")],
+    "chebyshevu": [(lambda *x: True, "ChebyshevU")],
+    "legendre": [(lambda *x: True, "LegendreP")],
+    "assoc_legendre": [(lambda *x: True, "LegendreP")],
+    "mathieuc": [(lambda *x: True, "MathieuC")],
+    "mathieus": [(lambda *x: True, "MathieuS")],
+    "mathieucprime": [(lambda *x: True, "MathieuCPrime")],
+    "mathieusprime": [(lambda *x: True, "MathieuSPrime")],
+    "stieltjes": [(lambda x: True, "StieltjesGamma")],
+    "elliptic_e": [(lambda *x: True, "EllipticE")],
+    "elliptic_f": [(lambda *x: True, "EllipticE")],
+    "elliptic_k": [(lambda x: True, "EllipticK")],
+    "elliptic_pi": [(lambda *x: True, "EllipticPi")],
+    "zeta": [(lambda *x: True, "Zeta")],
+    "dirichlet_eta": [(lambda x: True, "DirichletEta")],
+    "riemann_xi": [(lambda x: True, "RiemannXi")],
+    "besseli": [(lambda *x: True, "BesselI")],
+    "besselj": [(lambda *x: True, "BesselJ")],
+    "besselk": [(lambda *x: True, "BesselK")],
+    "bessely": [(lambda *x: True, "BesselY")],
+    "hankel1": [(lambda *x: True, "HankelH1")],
+    "hankel2": [(lambda *x: True, "HankelH2")],
+    "airyai": [(lambda x: True, "AiryAi")],
+    "airybi": [(lambda x: True, "AiryBi")],
+    "airyaiprime": [(lambda x: True, "AiryAiPrime")],
+    "airybiprime": [(lambda x: True, "AiryBiPrime")],
+    "polylog": [(lambda *x: True, "PolyLog")],
+    "lerchphi": [(lambda *x: True, "LerchPhi")],
+    "gcd": [(lambda *x: True, "GCD")],
+    "lcm": [(lambda *x: True, "LCM")],
+    "jn": [(lambda *x: True, "SphericalBesselJ")],
+    "yn": [(lambda *x: True, "SphericalBesselY")],
+    "hyper": [(lambda *x: True, "HypergeometricPFQ")],
+    "meijerg": [(lambda *x: True, "MeijerG")],
+    "appellf1": [(lambda *x: True, "AppellF1")],
+    "DiracDelta": [(lambda x: True, "DiracDelta")],
+    "Heaviside": [(lambda x: True, "HeavisideTheta")],
+    "KroneckerDelta": [(lambda *x: True, "KroneckerDelta")],
+    "sqrt": [(lambda x: True, "Sqrt")],  # For automatic rewrites
+}
+
+
+class MCodePrinter(CodePrinter):
+    """A printer to convert Python expressions to
+    strings of the Wolfram's Mathematica code
+    """
+    printmethod = "_mcode"
+    language = "Wolfram Language"
+
+    _default_settings: dict[str, Any] = {
+        'order': None,
+        'full_prec': 'auto',
+        'precision': 15,
+        'user_functions': {},
+        'human': True,
+        'allow_unknown_functions': False,
+    }
+
+    _number_symbols: set[tuple[Expr, Float]] = set()
+    _not_supported: set[Basic] = set()
+
+    def __init__(self, settings={}):
+        """Register function mappings supplied by user"""
+        CodePrinter.__init__(self, settings)
+        self.known_functions = dict(known_functions)
+        userfuncs = settings.get('user_functions', {}).copy()
+        for k, v in userfuncs.items():
+            if not isinstance(v, list):
+                userfuncs[k] = [(lambda *x: True, v)]
+        self.known_functions.update(userfuncs)
+
+    def _format_code(self, lines):
+        return lines
+
+    def _print_Pow(self, expr):
+        PREC = precedence(expr)
+        return '%s^%s' % (self.parenthesize(expr.base, PREC),
+                          self.parenthesize(expr.exp, PREC))
+
+    def _print_Mul(self, expr):
+        PREC = precedence(expr)
+        c, nc = expr.args_cnc()
+        res = super()._print_Mul(expr.func(*c))
+        if nc:
+            res += '*'
+            res += '**'.join(self.parenthesize(a, PREC) for a in nc)
+        return res
+
+    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)
+
+    # Primitive numbers
+    def _print_Zero(self, expr):
+        return '0'
+
+    def _print_One(self, expr):
+        return '1'
+
+    def _print_NegativeOne(self, expr):
+        return '-1'
+
+    def _print_Half(self, expr):
+        return '1/2'
+
+    def _print_ImaginaryUnit(self, expr):
+        return 'I'
+
+
+    # Infinity and invalid numbers
+    def _print_Infinity(self, expr):
+        return 'Infinity'
+
+    def _print_NegativeInfinity(self, expr):
+        return '-Infinity'
+
+    def _print_ComplexInfinity(self, expr):
+        return 'ComplexInfinity'
+
+    def _print_NaN(self, expr):
+        return 'Indeterminate'
+
+
+    # Mathematical constants
+    def _print_Exp1(self, expr):
+        return 'E'
+
+    def _print_Pi(self, expr):
+        return 'Pi'
+
+    def _print_GoldenRatio(self, expr):
+        return 'GoldenRatio'
+
+    def _print_TribonacciConstant(self, expr):
+        expanded = expr.expand(func=True)
+        PREC = precedence(expr)
+        return self.parenthesize(expanded, PREC)
+
+    def _print_EulerGamma(self, expr):
+        return 'EulerGamma'
+
+    def _print_Catalan(self, expr):
+        return 'Catalan'
+
+
+    def _print_list(self, expr):
+        return '{' + ', '.join(self.doprint(a) for a in expr) + '}'
+    _print_tuple = _print_list
+    _print_Tuple = _print_list
+
+    def _print_ImmutableDenseMatrix(self, expr):
+        return self.doprint(expr.tolist())
+
+    def _print_ImmutableSparseMatrix(self, expr):
+
+        def print_rule(pos, val):
+            return '{} -> {}'.format(
+            self.doprint((pos[0]+1, pos[1]+1)), self.doprint(val))
+
+        def print_data():
+            items = sorted(expr.todok().items(), key=default_sort_key)
+            return '{' + \
+                ', '.join(print_rule(k, v) for k, v in items) + \
+                '}'
+
+        def print_dims():
+            return self.doprint(expr.shape)
+
+        return 'SparseArray[{}, {}]'.format(print_data(), print_dims())
+
+    def _print_ImmutableDenseNDimArray(self, expr):
+        return self.doprint(expr.tolist())
+
+    def _print_ImmutableSparseNDimArray(self, expr):
+        def print_string_list(string_list):
+            return '{' + ', '.join(a for a in string_list) + '}'
+
+        def to_mathematica_index(*args):
+            """Helper function to change Python style indexing to
+            Pathematica indexing.
+
+            Python indexing (0, 1 ... n-1)
+            -> Mathematica indexing (1, 2 ... n)
+            """
+            return tuple(i + 1 for i in args)
+
+        def print_rule(pos, val):
+            """Helper function to print a rule of Mathematica"""
+            return '{} -> {}'.format(self.doprint(pos), self.doprint(val))
+
+        def print_data():
+            """Helper function to print data part of Mathematica
+            sparse array.
+
+            It uses the fourth notation ``SparseArray[data,{d1,d2,...}]``
+            from
+            https://reference.wolfram.com/language/ref/SparseArray.html
+
+            ``data`` must be formatted with rule.
+            """
+            return print_string_list(
+                [print_rule(
+                    to_mathematica_index(*(expr._get_tuple_index(key))),
+                    value)
+                for key, value in sorted(expr._sparse_array.items())]
+            )
+
+        def print_dims():
+            """Helper function to print dimensions part of Mathematica
+            sparse array.
+
+            It uses the fourth notation ``SparseArray[data,{d1,d2,...}]``
+            from
+            https://reference.wolfram.com/language/ref/SparseArray.html
+            """
+            return self.doprint(expr.shape)
+
+        return 'SparseArray[{}, {}]'.format(print_data(), print_dims())
+
+    def _print_Function(self, expr):
+        if expr.func.__name__ in self.known_functions:
+            cond_mfunc = self.known_functions[expr.func.__name__]
+            for cond, mfunc in cond_mfunc:
+                if cond(*expr.args):
+                    return "%s[%s]" % (mfunc, self.stringify(expr.args, ", "))
+        elif expr.func.__name__ in self._rewriteable_functions:
+            # Simple rewrite to supported function possible
+            target_f, required_fs = self._rewriteable_functions[expr.func.__name__]
+            if self._can_print(target_f) and all(self._can_print(f) for f in required_fs):
+                return self._print(expr.rewrite(target_f))
+        return expr.func.__name__ + "[%s]" % self.stringify(expr.args, ", ")
+
+    _print_MinMaxBase = _print_Function
+
+    def _print_LambertW(self, expr):
+        if len(expr.args) == 1:
+            return "ProductLog[{}]".format(self._print(expr.args[0]))
+        return "ProductLog[{}, {}]".format(
+            self._print(expr.args[1]), self._print(expr.args[0]))
+
+    def _print_Integral(self, expr):
+        if len(expr.variables) == 1 and not expr.limits[0][1:]:
+            args = [expr.args[0], expr.variables[0]]
+        else:
+            args = expr.args
+        return "Hold[Integrate[" + ', '.join(self.doprint(a) for a in args) + "]]"
+
+    def _print_Sum(self, expr):
+        return "Hold[Sum[" + ', '.join(self.doprint(a) for a in expr.args) + "]]"
+
+    def _print_Derivative(self, expr):
+        dexpr = expr.expr
+        dvars = [i[0] if i[1] == 1 else i for i in expr.variable_count]
+        return "Hold[D[" + ', '.join(self.doprint(a) for a in [dexpr] + dvars) + "]]"
+
+
+    def _get_comment(self, text):
+        return "(* {} *)".format(text)
+
+
+def mathematica_code(expr, **settings):
+    r"""Converts an expr to a string of the Wolfram Mathematica code
+
+    Examples
+    ========
+
+    >>> from sympy import mathematica_code as mcode, symbols, sin
+    >>> x = symbols('x')
+    >>> mcode(sin(x).series(x).removeO())
+    '(1/120)*x^5 - 1/6*x^3 + x'
+    """
+    return MCodePrinter(settings).doprint(expr)

env-llmeval/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

env-llmeval/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)

env-llmeval/lib/python3.10/site-packages/sympy/printing/octave.py

@@ -0,0 +1,719 @@
+"""
+Octave (and Matlab) code printer
+
+The `OctaveCodePrinter` converts SymPy expressions into Octave expressions.
+It uses a subset of the Octave language for Matlab compatibility.
+
+A complete code generator, which uses `octave_code` extensively, can be found
+in `sympy.utilities.codegen`.  The `codegen` module can be used to generate
+complete source code files.
+
+"""
+
+from __future__ import annotations
+from typing import Any
+
+from sympy.core import Mul, Pow, S, Rational
+from sympy.core.mul import _keep_coeff
+from sympy.core.numbers import equal_valued
+from sympy.printing.codeprinter import CodePrinter
+from sympy.printing.precedence import precedence, PRECEDENCE
+from re import search
+
+# List of known functions.  First, those that have the same name in
+# SymPy and Octave.   This is almost certainly incomplete!
+known_fcns_src1 = ["sin", "cos", "tan", "cot", "sec", "csc",
+                   "asin", "acos", "acot", "atan", "atan2", "asec", "acsc",
+                   "sinh", "cosh", "tanh", "coth", "csch", "sech",
+                   "asinh", "acosh", "atanh", "acoth", "asech", "acsch",
+                   "erfc", "erfi", "erf", "erfinv", "erfcinv",
+                   "besseli", "besselj", "besselk", "bessely",
+                   "bernoulli", "beta", "euler", "exp", "factorial", "floor",
+                   "fresnelc", "fresnels", "gamma", "harmonic", "log",
+                   "polylog", "sign", "zeta", "legendre"]
+
+# These functions have different names ("SymPy": "Octave"), more
+# generally a mapping to (argument_conditions, octave_function).
+known_fcns_src2 = {
+    "Abs": "abs",
+    "arg": "angle",  # arg/angle ok in Octave but only angle in Matlab
+    "binomial": "bincoeff",
+    "ceiling": "ceil",
+    "chebyshevu": "chebyshevU",
+    "chebyshevt": "chebyshevT",
+    "Chi": "coshint",
+    "Ci": "cosint",
+    "conjugate": "conj",
+    "DiracDelta": "dirac",
+    "Heaviside": "heaviside",
+    "im": "imag",
+    "laguerre": "laguerreL",
+    "LambertW": "lambertw",
+    "li": "logint",
+    "loggamma": "gammaln",
+    "Max": "max",
+    "Min": "min",
+    "Mod": "mod",
+    "polygamma": "psi",
+    "re": "real",
+    "RisingFactorial": "pochhammer",
+    "Shi": "sinhint",
+    "Si": "sinint",
+}
+
+
+class OctaveCodePrinter(CodePrinter):
+    """
+    A printer to convert expressions to strings of Octave/Matlab code.
+    """
+    printmethod = "_octave"
+    language = "Octave"
+
+    _operators = {
+        'and': '&',
+        'or': '|',
+        'not': '~',
+    }
+
+    _default_settings: dict[str, Any] = {
+        'order': None,
+        'full_prec': 'auto',
+        'precision': 17,
+        'user_functions': {},
+        'human': True,
+        'allow_unknown_functions': False,
+        'contract': True,
+        'inline': True,
+    }
+    # Note: contract is for expressing tensors as loops (if True), or just
+    # assignment (if False).  FIXME: this should be looked a more carefully
+    # for Octave.
+
+
+    def __init__(self, settings={}):
+        super().__init__(settings)
+        self.known_functions = dict(zip(known_fcns_src1, known_fcns_src1))
+        self.known_functions.update(dict(known_fcns_src2))
+        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 "{} = {};".format(name, value)
+
+
+    def _format_code(self, lines):
+        return self.indent_code(lines)
+
+
+    def _traverse_matrix_indices(self, mat):
+        # Octave uses Fortran order (column-major)
+        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:
+            # Octave 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("for %s = %s:%s" % (var, start, stop))
+            close_lines.append("end")
+        return open_lines, close_lines
+
+
+    def _print_Mul(self, expr):
+        # print complex numbers nicely in Octave
+        if (expr.is_number and expr.is_imaginary and
+                (S.ImaginaryUnit*expr).is_Integer):
+            return "%si" % self._print(-S.ImaginaryUnit*expr)
+
+        # cribbed from str.py
+        prec = precedence(expr)
+
+        c, e = expr.as_coeff_Mul()
+        if c < 0:
+            expr = _keep_coeff(-c, e)
+            sign = "-"
+        else:
+            sign = ""
+
+        a = []  # items in the numerator
+        b = []  # items that are in the denominator (if any)
+
+        pow_paren = []  # Will collect all pow with more than one base element and exp = -1
+
+        if self.order not in ('old', 'none'):
+            args = expr.as_ordered_factors()
+        else:
+            # use make_args in case expr was something like -x -> x
+            args = Mul.make_args(expr)
+
+        # Gather args for numerator/denominator
+        for item in args:
+            if (item.is_commutative and item.is_Pow and item.exp.is_Rational
+                    and item.exp.is_negative):
+                if item.exp != -1:
+                    b.append(Pow(item.base, -item.exp, evaluate=False))
+                else:
+                    if len(item.args[0].args) != 1 and isinstance(item.base, Mul):   # To avoid situations like #14160
+                        pow_paren.append(item)
+                    b.append(Pow(item.base, -item.exp))
+            elif item.is_Rational and item is not S.Infinity:
+                if item.p != 1:
+                    a.append(Rational(item.p))
+                if item.q != 1:
+                    b.append(Rational(item.q))
+            else:
+                a.append(item)
+
+        a = a or [S.One]
+
+        a_str = [self.parenthesize(x, prec) for x in a]
+        b_str = [self.parenthesize(x, prec) for x in b]
+
+        # To parenthesize Pow with exp = -1 and having more than one Symbol
+        for item in pow_paren:
+            if item.base in b:
+                b_str[b.index(item.base)] = "(%s)" % b_str[b.index(item.base)]
+
+        # from here it differs from str.py to deal with "*" and ".*"
+        def multjoin(a, a_str):
+            # here we probably are assuming the constants will come first
+            r = a_str[0]
+            for i in range(1, len(a)):
+                mulsym = '*' if a[i-1].is_number else '.*'
+                r = r + mulsym + a_str[i]
+            return r
+
+        if not b:
+            return sign + multjoin(a, a_str)
+        elif len(b) == 1:
+            divsym = '/' if b[0].is_number else './'
+            return sign + multjoin(a, a_str) + divsym + b_str[0]
+        else:
+            divsym = '/' if all(bi.is_number for bi in b) else './'
+            return (sign + multjoin(a, a_str) +
+                    divsym + "(%s)" % multjoin(b, b_str))
+
+    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_Pow(self, expr):
+        powsymbol = '^' if all(x.is_number for x in expr.args) else '.^'
+
+        PREC = precedence(expr)
+
+        if equal_valued(expr.exp, 0.5):
+            return "sqrt(%s)" % self._print(expr.base)
+
+        if expr.is_commutative:
+            if equal_valued(expr.exp, -0.5):
+                sym = '/' if expr.base.is_number else './'
+                return "1" + sym + "sqrt(%s)" % self._print(expr.base)
+            if equal_valued(expr.exp, -1):
+                sym = '/' if expr.base.is_number else './'
+                return "1" + sym + "%s" % self.parenthesize(expr.base, PREC)
+
+        return '%s%s%s' % (self.parenthesize(expr.base, PREC), powsymbol,
+                           self.parenthesize(expr.exp, PREC))
+
+
+    def _print_MatPow(self, expr):
+        PREC = precedence(expr)
+        return '%s^%s' % (self.parenthesize(expr.base, PREC),
+                          self.parenthesize(expr.exp, PREC))
+
+    def _print_MatrixSolve(self, expr):
+        PREC = precedence(expr)
+        return "%s \\ %s" % (self.parenthesize(expr.matrix, PREC),
+                             self.parenthesize(expr.vector, PREC))
+
+    def _print_Pi(self, expr):
+        return 'pi'
+
+
+    def _print_ImaginaryUnit(self, expr):
+        return "1i"
+
+
+    def _print_Exp1(self, expr):
+        return "exp(1)"
+
+
+    def _print_GoldenRatio(self, expr):
+        # FIXME: how to do better, e.g., for octave_code(2*GoldenRatio)?
+        #return self._print((1+sqrt(S(5)))/2)
+        return "(1+sqrt(5))/2"
+
+
+    def _print_Assignment(self, expr):
+        from sympy.codegen.ast import Assignment
+        from sympy.functions.elementary.piecewise import Piecewise
+        from sympy.tensor.indexed import IndexedBase
+        # Copied from codeprinter, but remove special MatrixSymbol treatment
+        lhs = expr.lhs
+        rhs = expr.rhs
+        # We special case assignments that take multiple lines
+        if not self._settings["inline"] and isinstance(expr.rhs, Piecewise):
+            # Here we modify Piecewise so each expression is now
+            # an Assignment, and then continue on the print.
+            expressions = []
+            conditions = []
+            for (e, c) in rhs.args:
+                expressions.append(Assignment(lhs, e))
+                conditions.append(c)
+            temp = Piecewise(*zip(expressions, conditions))
+            return self._print(temp)
+        if self._settings["contract"] and (lhs.has(IndexedBase) or
+                rhs.has(IndexedBase)):
+            # Here we check if there is looping to be done, and if so
+            # print the required loops.
+            return self._doprint_loops(rhs, lhs)
+        else:
+            lhs_code = self._print(lhs)
+            rhs_code = self._print(rhs)
+            return self._get_statement("%s = %s" % (lhs_code, rhs_code))
+
+
+    def _print_Infinity(self, expr):
+        return 'inf'
+
+
+    def _print_NegativeInfinity(self, expr):
+        return '-inf'
+
+
+    def _print_NaN(self, expr):
+        return 'NaN'
+
+
+    def _print_list(self, expr):
+        return '{' + ', '.join(self._print(a) for a in expr) + '}'
+    _print_tuple = _print_list
+    _print_Tuple = _print_list
+    _print_List = _print_list
+
+
+    def _print_BooleanTrue(self, expr):
+        return "true"
+
+
+    def _print_BooleanFalse(self, expr):
+        return "false"
+
+
+    def _print_bool(self, expr):
+        return str(expr).lower()
+
+
+    # Could generate quadrature code for definite Integrals?
+    #_print_Integral = _print_not_supported
+
+
+    def _print_MatrixBase(self, A):
+        # Handle zero dimensions:
+        if (A.rows, A.cols) == (0, 0):
+            return '[]'
+        elif S.Zero in A.shape:
+            return 'zeros(%s, %s)' % (A.rows, A.cols)
+        elif (A.rows, A.cols) == (1, 1):
+            # Octave does not distinguish between scalars and 1x1 matrices
+            return self._print(A[0, 0])
+        return "[%s]" % "; ".join(" ".join([self._print(a) for a in A[r, :]])
+                                  for r in range(A.rows))
+
+
+    def _print_SparseRepMatrix(self, A):
+        from sympy.matrices import Matrix
+        L = A.col_list();
+        # make row vectors of the indices and entries
+        I = Matrix([[k[0] + 1 for k in L]])
+        J = Matrix([[k[1] + 1 for k in L]])
+        AIJ = Matrix([[k[2] for k in L]])
+        return "sparse(%s, %s, %s, %s, %s)" % (self._print(I), self._print(J),
+                                            self._print(AIJ), A.rows, A.cols)
+
+
+    def _print_MatrixElement(self, expr):
+        return self.parenthesize(expr.parent, PRECEDENCE["Atom"], strict=True) \
+            + '(%s, %s)' % (expr.i + 1, expr.j + 1)
+
+
+    def _print_MatrixSlice(self, expr):
+        def strslice(x, lim):
+            l = x[0] + 1
+            h = x[1]
+            step = x[2]
+            lstr = self._print(l)
+            hstr = 'end' if h == lim else self._print(h)
+            if step == 1:
+                if l == 1 and h == lim:
+                    return ':'
+                if l == h:
+                    return lstr
+                else:
+                    return lstr + ':' + hstr
+            else:
+                return ':'.join((lstr, self._print(step), hstr))
+        return (self._print(expr.parent) + '(' +
+                strslice(expr.rowslice, expr.parent.shape[0]) + ', ' +
+                strslice(expr.colslice, expr.parent.shape[1]) + ')')
+
+
+    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_KroneckerDelta(self, expr):
+        prec = PRECEDENCE["Pow"]
+        return "double(%s == %s)" % tuple(self.parenthesize(x, prec)
+                                          for x in expr.args)
+
+    def _print_HadamardProduct(self, expr):
+        return '.*'.join([self.parenthesize(arg, precedence(expr))
+                          for arg in expr.args])
+
+    def _print_HadamardPower(self, expr):
+        PREC = precedence(expr)
+        return '.**'.join([
+            self.parenthesize(expr.base, PREC),
+            self.parenthesize(expr.exp, PREC)
+            ])
+
+    def _print_Identity(self, expr):
+        shape = expr.shape
+        if len(shape) == 2 and shape[0] == shape[1]:
+            shape = [shape[0]]
+        s = ", ".join(self._print(n) for n in shape)
+        return "eye(" + s + ")"
+
+    def _print_lowergamma(self, expr):
+        # Octave implements regularized incomplete gamma function
+        return "(gammainc({1}, {0}).*gamma({0}))".format(
+            self._print(expr.args[0]), self._print(expr.args[1]))
+
+
+    def _print_uppergamma(self, expr):
+        return "(gammainc({1}, {0}, 'upper').*gamma({0}))".format(
+            self._print(expr.args[0]), self._print(expr.args[1]))
+
+
+    def _print_sinc(self, expr):
+        #Note: Divide by pi because Octave implements normalized sinc function.
+        return "sinc(%s)" % self._print(expr.args[0]/S.Pi)
+
+
+    def _print_hankel1(self, expr):
+        return "besselh(%s, 1, %s)" % (self._print(expr.order),
+                                       self._print(expr.argument))
+
+
+    def _print_hankel2(self, expr):
+        return "besselh(%s, 2, %s)" % (self._print(expr.order),
+                                       self._print(expr.argument))
+
+
+    # Note: as of 2015, Octave doesn't have spherical Bessel functions
+    def _print_jn(self, expr):
+        from sympy.functions import sqrt, besselj
+        x = expr.argument
+        expr2 = sqrt(S.Pi/(2*x))*besselj(expr.order + S.Half, x)
+        return self._print(expr2)
+
+
+    def _print_yn(self, expr):
+        from sympy.functions import sqrt, bessely
+        x = expr.argument
+        expr2 = sqrt(S.Pi/(2*x))*bessely(expr.order + S.Half, x)
+        return self._print(expr2)
+
+
+    def _print_airyai(self, expr):
+        return "airy(0, %s)" % self._print(expr.args[0])
+
+
+    def _print_airyaiprime(self, expr):
+        return "airy(1, %s)" % self._print(expr.args[0])
+
+
+    def _print_airybi(self, expr):
+        return "airy(2, %s)" % self._print(expr.args[0])
+
+
+    def _print_airybiprime(self, expr):
+        return "airy(3, %s)" % self._print(expr.args[0])
+
+
+    def _print_expint(self, expr):
+        mu, x = expr.args
+        if mu != 1:
+            return self._print_not_supported(expr)
+        return "expint(%s)" % self._print(x)
+
+
+    def _one_or_two_reversed_args(self, expr):
+        assert len(expr.args) <= 2
+        return '{name}({args})'.format(
+            name=self.known_functions[expr.__class__.__name__],
+            args=", ".join([self._print(x) for x in reversed(expr.args)])
+        )
+
+
+    _print_DiracDelta = _print_LambertW = _one_or_two_reversed_args
+
+
+    def _nested_binary_math_func(self, expr):
+        return '{name}({arg1}, {arg2})'.format(
+            name=self.known_functions[expr.__class__.__name__],
+            arg1=self._print(expr.args[0]),
+            arg2=self._print(expr.func(*expr.args[1:]))
+            )
+
+    _print_Max = _print_Min = _nested_binary_math_func
+
+
+    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 self._settings["inline"]:
+            # Express each (cond, expr) pair in a nested Horner form:
+            #   (condition) .* (expr) + (not cond) .* (<others>)
+            # Expressions that result in multiple statements won't work here.
+            ecpairs = ["({0}).*({1}) + (~({0})).*(".format
+                       (self._print(c), self._print(e))
+                       for e, c in expr.args[:-1]]
+            elast = "%s" % self._print(expr.args[-1].expr)
+            pw = " ...\n".join(ecpairs) + elast + ")"*len(ecpairs)
+            # Note: current need these outer brackets for 2*pw.  Would be
+            # nicer to teach parenthesize() to do this for us when needed!
+            return "(" + pw + ")"
+        else:
+            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("elseif (%s)" % self._print(c))
+                code0 = self._print(e)
+                lines.append(code0)
+                if i == len(expr.args) - 1:
+                    lines.append("end")
+            return "\n".join(lines)
+
+
+    def _print_zeta(self, expr):
+        if len(expr.args) == 1:
+            return "zeta(%s)" % self._print(expr.args[0])
+        else:
+            # Matlab two argument zeta is not equivalent to SymPy's
+            return self._print_not_supported(expr)
+
+
+    def indent_code(self, code):
+        """Accepts a string of code or a list of code lines"""
+
+        # code mostly copied from ccode
+        if isinstance(code, str):
+            code_lines = self.indent_code(code.splitlines(True))
+            return ''.join(code_lines)
+
+        tab = "  "
+        inc_regex = ('^function ', '^if ', '^elseif ', '^else$', '^for ')
+        dec_regex = ('^end$', '^elseif ', '^else$')
+
+        # pre-strip left-space from the code
+        code = [ line.lstrip(' \t') for line in code ]
+
+        increase = [ int(any(search(re, line) for re in inc_regex))
+                     for line in code ]
+        decrease = [ int(any(search(re, line) for re in dec_regex))
+                     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 octave_code(expr, assign_to=None, **settings):
+    r"""Converts `expr` to a string of Octave (or Matlab) code.
+
+    The string uses a subset of the Octave language for Matlab compatibility.
+
+    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].
+
+    Examples
+    ========
+
+    >>> from sympy import octave_code, symbols, sin, pi
+    >>> x = symbols('x')
+    >>> octave_code(sin(x).series(x).removeO())
+    'x.^5/120 - x.^3/6 + x'
+
+    >>> from sympy import Rational, ceiling
+    >>> x, y, tau = symbols("x, y, tau")
+    >>> octave_code((2*tau)**Rational(7, 2))
+    '8*sqrt(2)*tau.^(7/2)'
+
+    Note that element-wise (Hadamard) operations are used by default between
+    symbols.  This is because its very common in Octave to write "vectorized"
+    code.  It is harmless if the values are scalars.
+
+    >>> octave_code(sin(pi*x*y), assign_to="s")
+    's = sin(pi*x.*y);'
+
+    If you need a matrix product "*" or matrix power "^", you can specify the
+    symbol as a ``MatrixSymbol``.
+
+    >>> from sympy import Symbol, MatrixSymbol
+    >>> n = Symbol('n', integer=True, positive=True)
+    >>> A = MatrixSymbol('A', n, n)
+    >>> octave_code(3*pi*A**3)
+    '(3*pi)*A^3'
+
+    This class uses several rules to decide which symbol to use a product.
+    Pure numbers use "*", Symbols use ".*" and MatrixSymbols use "*".
+    A HadamardProduct can be used to specify componentwise multiplication ".*"
+    of two MatrixSymbols.  There is currently there is no easy way to specify
+    scalar symbols, so sometimes the code might have some minor cosmetic
+    issues.  For example, suppose x and y are scalars and A is a Matrix, then
+    while a human programmer might write "(x^2*y)*A^3", we generate:
+
+    >>> octave_code(x**2*y*A**3)
+    '(x.^2.*y)*A^3'
+
+    Matrices are supported using Octave inline notation.  When using
+    ``assign_to`` with matrices, the name can be specified either as a string
+    or as a ``MatrixSymbol``.  The dimensions must align in the latter case.
+
+    >>> from sympy import Matrix, MatrixSymbol
+    >>> mat = Matrix([[x**2, sin(x), ceiling(x)]])
+    >>> octave_code(mat, assign_to='A')
+    'A = [x.^2 sin(x) ceil(x)];'
+
+    ``Piecewise`` expressions are implemented with logical masking by default.
+    Alternatively, you can pass "inline=False" to use if-else conditionals.
+    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
+    >>> pw = Piecewise((x + 1, x > 0), (x, True))
+    >>> octave_code(pw, assign_to=tau)
+    'tau = ((x > 0).*(x + 1) + (~(x > 0)).*(x));'
+
+    Note that any expression that can be generated normally can also exist
+    inside a Matrix:
+
+    >>> mat = Matrix([[x**2, pw, sin(x)]])
+    >>> octave_code(mat, assign_to='A')
+    'A = [x.^2 ((x > 0).*(x + 1) + (~(x > 0)).*(x)) 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,
+    cfunction_string)].  This can be used to call a custom Octave function.
+
+    >>> from sympy import Function
+    >>> f = Function('f')
+    >>> g = Function('g')
+    >>> custom_functions = {
+    ...   "f": "existing_octave_fcn",
+    ...   "g": [(lambda x: x.is_Matrix, "my_mat_fcn"),
+    ...         (lambda x: not x.is_Matrix, "my_fcn")]
+    ... }
+    >>> mat = Matrix([[1, x]])
+    >>> octave_code(f(x) + g(x) + g(mat), user_functions=custom_functions)
+    'existing_octave_fcn(x) + my_fcn(x) + my_mat_fcn([1 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]))
+    >>> octave_code(e.rhs, assign_to=e.lhs, contract=False)
+    'Dy(i) = (y(i + 1) - y(i))./(t(i + 1) - t(i));'
+    """
+    return OctaveCodePrinter(settings).doprint(expr, assign_to)
+
+
+def print_octave_code(expr, **settings):
+    """Prints the Octave (or Matlab) representation of the given expression.
+
+    See `octave_code` for the meaning of the optional arguments.
+    """
+    print(octave_code(expr, **settings))

env-llmeval/lib/python3.10/site-packages/sympy/printing/preview.py

@@ -0,0 +1,390 @@
+import os
+from os.path import join
+import shutil
+import tempfile
+
+try:
+    from subprocess import STDOUT, CalledProcessError, check_output
+except ImportError:
+    pass
+
+from sympy.utilities.decorator import doctest_depends_on
+from sympy.utilities.misc import debug
+from .latex import latex
+
+__doctest_requires__ = {('preview',): ['pyglet']}
+
+
+def _check_output_no_window(*args, **kwargs):
+    # Avoid showing a cmd.exe window when running this
+    # on Windows
+    if os.name == 'nt':
+        creation_flag = 0x08000000 # CREATE_NO_WINDOW
+    else:
+        creation_flag = 0 # Default value
+    return check_output(*args, creationflags=creation_flag, **kwargs)
+
+
+def system_default_viewer(fname, fmt):
+    """ Open fname with the default system viewer.
+
+    In practice, it is impossible for python to know when the system viewer is
+    done. For this reason, we ensure the passed file will not be deleted under
+    it, and this function does not attempt to block.
+    """
+    # copy to a new temporary file that will not be deleted
+    with tempfile.NamedTemporaryFile(prefix='sympy-preview-',
+                                     suffix=os.path.splitext(fname)[1],
+                                     delete=False) as temp_f:
+        with open(fname, 'rb') as f:
+            shutil.copyfileobj(f, temp_f)
+
+    import platform
+    if platform.system() == 'Darwin':
+        import subprocess
+        subprocess.call(('open', temp_f.name))
+    elif platform.system() == 'Windows':
+        os.startfile(temp_f.name)
+    else:
+        import subprocess
+        subprocess.call(('xdg-open', temp_f.name))
+
+
+def pyglet_viewer(fname, fmt):
+    try:
+        from pyglet import window, image, gl
+        from pyglet.window import key
+        from pyglet.image.codecs import ImageDecodeException
+    except ImportError:
+        raise ImportError("pyglet is required for preview.\n visit https://pyglet.org/")
+
+    try:
+        img = image.load(fname)
+    except ImageDecodeException:
+        raise ValueError("pyglet preview does not work for '{}' files.".format(fmt))
+
+    offset = 25
+
+    config = gl.Config(double_buffer=False)
+    win = window.Window(
+        width=img.width + 2*offset,
+        height=img.height + 2*offset,
+        caption="SymPy",
+        resizable=False,
+        config=config
+    )
+
+    win.set_vsync(False)
+
+    try:
+        def on_close():
+            win.has_exit = True
+
+        win.on_close = on_close
+
+        def on_key_press(symbol, modifiers):
+            if symbol in [key.Q, key.ESCAPE]:
+                on_close()
+
+        win.on_key_press = on_key_press
+
+        def on_expose():
+            gl.glClearColor(1.0, 1.0, 1.0, 1.0)
+            gl.glClear(gl.GL_COLOR_BUFFER_BIT)
+
+            img.blit(
+                (win.width - img.width) / 2,
+                (win.height - img.height) / 2
+            )
+
+        win.on_expose = on_expose
+
+        while not win.has_exit:
+            win.dispatch_events()
+            win.flip()
+    except KeyboardInterrupt:
+        pass
+
+    win.close()
+
+
+def _get_latex_main(expr, *, preamble=None, packages=(), extra_preamble=None,
+                    euler=True, fontsize=None, **latex_settings):
+    """
+    Generate string of a LaTeX document rendering ``expr``.
+    """
+    if preamble is None:
+        actual_packages = packages + ("amsmath", "amsfonts")
+        if euler:
+            actual_packages += ("euler",)
+        package_includes = "\n" + "\n".join(["\\usepackage{%s}" % p
+                                             for p in actual_packages])
+        if extra_preamble:
+            package_includes += extra_preamble
+
+        if not fontsize:
+            fontsize = "12pt"
+        elif isinstance(fontsize, int):
+            fontsize = "{}pt".format(fontsize)
+        preamble = r"""\documentclass[varwidth,%s]{standalone}
+%s
+
+\begin{document}
+""" % (fontsize, package_includes)
+    else:
+        if packages or extra_preamble:
+            raise ValueError("The \"packages\" or \"extra_preamble\" keywords"
+                             "must not be set if a "
+                             "custom LaTeX preamble was specified")
+
+    if isinstance(expr, str):
+        latex_string = expr
+    else:
+        latex_string = ('$\\displaystyle ' +
+                        latex(expr, mode='plain', **latex_settings) +
+                        '$')
+
+    return preamble + '\n' + latex_string + '\n\n' + r"\end{document}"
+
+
+@doctest_depends_on(exe=('latex', 'dvipng'), modules=('pyglet',),
+            disable_viewers=('evince', 'gimp', 'superior-dvi-viewer'))
+def preview(expr, output='png', viewer=None, euler=True, packages=(),
+            filename=None, outputbuffer=None, preamble=None, dvioptions=None,
+            outputTexFile=None, extra_preamble=None, fontsize=None,
+            **latex_settings):
+    r"""
+    View expression or LaTeX markup in PNG, DVI, PostScript or PDF form.
+
+    If the expr argument is an expression, it will be exported to LaTeX and
+    then compiled using the available TeX distribution.  The first argument,
+    'expr', may also be a LaTeX string.  The function will then run the
+    appropriate viewer for the given output format or use the user defined
+    one. By default png output is generated.
+
+    By default pretty Euler fonts are used for typesetting (they were used to
+    typeset the well known "Concrete Mathematics" book). For that to work, you
+    need the 'eulervm.sty' LaTeX style (in Debian/Ubuntu, install the
+    texlive-fonts-extra package). If you prefer default AMS fonts or your
+    system lacks 'eulervm' LaTeX package then unset the 'euler' keyword
+    argument.
+
+    To use viewer auto-detection, lets say for 'png' output, issue
+
+    >>> from sympy import symbols, preview, Symbol
+    >>> x, y = symbols("x,y")
+
+    >>> preview(x + y, output='png')
+
+    This will choose 'pyglet' by default. To select a different one, do
+
+    >>> preview(x + y, output='png', viewer='gimp')
+
+    The 'png' format is considered special. For all other formats the rules
+    are slightly different. As an example we will take 'dvi' output format. If
+    you would run
+
+    >>> preview(x + y, output='dvi')
+
+    then 'view' will look for available 'dvi' viewers on your system
+    (predefined in the function, so it will try evince, first, then kdvi and
+    xdvi). If nothing is found, it will fall back to using a system file
+    association (via ``open`` and ``xdg-open``). To always use your system file
+    association without searching for the above readers, use
+
+    >>> from sympy.printing.preview import system_default_viewer
+    >>> preview(x + y, output='dvi', viewer=system_default_viewer)
+
+    If this still does not find the viewer you want, it can be set explicitly.
+
+    >>> preview(x + y, output='dvi', viewer='superior-dvi-viewer')
+
+    This will skip auto-detection and will run user specified
+    'superior-dvi-viewer'. If ``view`` fails to find it on your system it will
+    gracefully raise an exception.
+
+    You may also enter ``'file'`` for the viewer argument. Doing so will cause
+    this function to return a file object in read-only mode, if ``filename``
+    is unset. However, if it was set, then 'preview' writes the generated
+    file to this filename instead.
+
+    There is also support for writing to a ``io.BytesIO`` like object, which
+    needs to be passed to the ``outputbuffer`` argument.
+
+    >>> from io import BytesIO
+    >>> obj = BytesIO()
+    >>> preview(x + y, output='png', viewer='BytesIO',
+    ...         outputbuffer=obj)
+
+    The LaTeX preamble can be customized by setting the 'preamble' keyword
+    argument. This can be used, e.g., to set a different font size, use a
+    custom documentclass or import certain set of LaTeX packages.
+
+    >>> preamble = "\\documentclass[10pt]{article}\n" \
+    ...            "\\usepackage{amsmath,amsfonts}\\begin{document}"
+    >>> preview(x + y, output='png', preamble=preamble)
+
+    It is also possible to use the standard preamble and provide additional
+    information to the preamble using the ``extra_preamble`` keyword argument.
+
+    >>> from sympy import sin
+    >>> extra_preamble = "\\renewcommand{\\sin}{\\cos}"
+    >>> preview(sin(x), output='png', extra_preamble=extra_preamble)
+
+    If the value of 'output' is different from 'dvi' then command line
+    options can be set ('dvioptions' argument) for the execution of the
+    'dvi'+output conversion tool. These options have to be in the form of a
+    list of strings (see ``subprocess.Popen``).
+
+    Additional keyword args will be passed to the :func:`~sympy.printing.latex.latex` call,
+    e.g., the ``symbol_names`` flag.
+
+    >>> phidd = Symbol('phidd')
+    >>> preview(phidd, symbol_names={phidd: r'\ddot{\varphi}'})
+
+    For post-processing the generated TeX File can be written to a file by
+    passing the desired filename to the 'outputTexFile' keyword
+    argument. To write the TeX code to a file named
+    ``"sample.tex"`` and run the default png viewer to display the resulting
+    bitmap, do
+
+    >>> preview(x + y, outputTexFile="sample.tex")
+
+
+    """
+    # pyglet is the default for png
+    if viewer is None and output == "png":
+        try:
+            import pyglet  # noqa: F401
+        except ImportError:
+            pass
+        else:
+            viewer = pyglet_viewer
+
+    # look up a known application
+    if viewer is None:
+        # sorted in order from most pretty to most ugly
+        # very discussable, but indeed 'gv' looks awful :)
+        candidates = {
+            "dvi": [ "evince", "okular", "kdvi", "xdvi" ],
+            "ps": [ "evince", "okular", "gsview", "gv" ],
+            "pdf": [ "evince", "okular", "kpdf", "acroread", "xpdf", "gv" ],
+        }
+
+        for candidate in candidates.get(output, []):
+            path = shutil.which(candidate)
+            if path is not None:
+                viewer = path
+                break
+
+    # otherwise, use the system default for file association
+    if viewer is None:
+        viewer = system_default_viewer
+
+    if viewer == "file":
+        if filename is None:
+            raise ValueError("filename has to be specified if viewer=\"file\"")
+    elif viewer == "BytesIO":
+        if outputbuffer is None:
+            raise ValueError("outputbuffer has to be a BytesIO "
+                             "compatible object if viewer=\"BytesIO\"")
+    elif not callable(viewer) and not shutil.which(viewer):
+        raise OSError("Unrecognized viewer: %s" % viewer)
+
+    latex_main = _get_latex_main(expr, preamble=preamble, packages=packages,
+                                 euler=euler, extra_preamble=extra_preamble,
+                                 fontsize=fontsize, **latex_settings)
+
+    debug("Latex code:")
+    debug(latex_main)
+    with tempfile.TemporaryDirectory() as workdir:
+        with open(join(workdir, 'texput.tex'), 'w', encoding='utf-8') as fh:
+            fh.write(latex_main)
+
+        if outputTexFile is not None:
+            shutil.copyfile(join(workdir, 'texput.tex'), outputTexFile)
+
+        if not shutil.which('latex'):
+            raise RuntimeError("latex program is not installed")
+
+        try:
+            _check_output_no_window(
+                ['latex', '-halt-on-error', '-interaction=nonstopmode',
+                 'texput.tex'],
+                cwd=workdir,
+                stderr=STDOUT)
+        except CalledProcessError as e:
+            raise RuntimeError(
+                "'latex' exited abnormally with the following output:\n%s" %
+                e.output)
+
+        src = "texput.%s" % (output)
+
+        if output != "dvi":
+            # in order of preference
+            commandnames = {
+                "ps": ["dvips"],
+                "pdf": ["dvipdfmx", "dvipdfm", "dvipdf"],
+                "png": ["dvipng"],
+                "svg": ["dvisvgm"],
+            }
+            try:
+                cmd_variants = commandnames[output]
+            except KeyError:
+                raise ValueError("Invalid output format: %s" % output) from None
+
+            # find an appropriate command
+            for cmd_variant in cmd_variants:
+                cmd_path = shutil.which(cmd_variant)
+                if cmd_path:
+                    cmd = [cmd_path]
+                    break
+            else:
+                if len(cmd_variants) > 1:
+                    raise RuntimeError("None of %s are installed" % ", ".join(cmd_variants))
+                else:
+                    raise RuntimeError("%s is not installed" % cmd_variants[0])
+
+            defaultoptions = {
+                "dvipng": ["-T", "tight", "-z", "9", "--truecolor"],
+                "dvisvgm": ["--no-fonts"],
+            }
+
+            commandend = {
+                "dvips": ["-o", src, "texput.dvi"],
+                "dvipdf": ["texput.dvi", src],
+                "dvipdfm": ["-o", src, "texput.dvi"],
+                "dvipdfmx": ["-o", src, "texput.dvi"],
+                "dvipng": ["-o", src, "texput.dvi"],
+                "dvisvgm": ["-o", src, "texput.dvi"],
+            }
+
+            if dvioptions is not None:
+                cmd.extend(dvioptions)
+            else:
+                cmd.extend(defaultoptions.get(cmd_variant, []))
+            cmd.extend(commandend[cmd_variant])
+
+            try:
+                _check_output_no_window(cmd, cwd=workdir, stderr=STDOUT)
+            except CalledProcessError as e:
+                raise RuntimeError(
+                    "'%s' exited abnormally with the following output:\n%s" %
+                    (' '.join(cmd), e.output))
+
+
+        if viewer == "file":
+            shutil.move(join(workdir, src), filename)
+        elif viewer == "BytesIO":
+            with open(join(workdir, src), 'rb') as fh:
+                outputbuffer.write(fh.read())
+        elif callable(viewer):
+            viewer(join(workdir, src), fmt=output)
+        else:
+            try:
+                _check_output_no_window(
+                    [viewer, src], cwd=workdir, stderr=STDOUT)
+            except CalledProcessError as e:
+                raise RuntimeError(
+                    "'%s %s' exited abnormally with the following output:\n%s" %
+                    (viewer, src, e.output))

env-llmeval/lib/python3.10/site-packages/sympy/printing/printer.py

@@ -0,0 +1,396 @@
+"""Printing subsystem driver
+
+SymPy's printing system works the following way: Any expression can be
+passed to a designated Printer who then is responsible to return an
+adequate representation of that expression.
+
+**The basic concept is the following:**
+
+1.  Let the object print itself if it knows how.
+2.  Take the best fitting method defined in the printer.
+3.  As fall-back use the emptyPrinter method for the printer.
+
+Which Method is Responsible for Printing?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The whole printing process is started by calling ``.doprint(expr)`` on the printer
+which you want to use. This method looks for an appropriate method which can
+print the given expression in the given style that the printer defines.
+While looking for the method, it follows these steps:
+
+1.  **Let the object print itself if it knows how.**
+
+    The printer looks for a specific method in every object. The name of that method
+    depends on the specific printer and is defined under ``Printer.printmethod``.
+    For example, StrPrinter calls ``_sympystr`` and LatexPrinter calls ``_latex``.
+    Look at the documentation of the printer that you want to use.
+    The name of the method is specified there.
+
+    This was the original way of doing printing in sympy. Every class had
+    its own latex, mathml, str and repr methods, but it turned out that it
+    is hard to produce a high quality printer, if all the methods are spread
+    out that far. Therefore all printing code was combined into the different
+    printers, which works great for built-in SymPy objects, but not that
+    good for user defined classes where it is inconvenient to patch the
+    printers.
+
+2.  **Take the best fitting method defined in the printer.**
+
+    The printer loops through expr classes (class + its bases), and tries
+    to dispatch the work to ``_print_<EXPR_CLASS>``
+
+    e.g., suppose we have the following class hierarchy::
+
+            Basic
+            |
+            Atom
+            |
+            Number
+            |
+        Rational
+
+    then, for ``expr=Rational(...)``, the Printer will try
+    to call printer methods in the order as shown in the figure below::
+
+        p._print(expr)
+        |
+        |-- p._print_Rational(expr)
+        |
+        |-- p._print_Number(expr)
+        |
+        |-- p._print_Atom(expr)
+        |
+        `-- p._print_Basic(expr)
+
+    if ``._print_Rational`` method exists in the printer, then it is called,
+    and the result is returned back. Otherwise, the printer tries to call
+    ``._print_Number`` and so on.
+
+3.  **As a fall-back use the emptyPrinter method for the printer.**
+
+    As fall-back ``self.emptyPrinter`` will be called with the expression. If
+    not defined in the Printer subclass this will be the same as ``str(expr)``.
+
+.. _printer_example:
+
+Example of Custom Printer
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In the example below, we have a printer which prints the derivative of a function
+in a shorter form.
+
+.. code-block:: python
+
+    from sympy.core.symbol import Symbol
+    from sympy.printing.latex import LatexPrinter, print_latex
+    from sympy.core.function import UndefinedFunction, Function
+
+
+    class MyLatexPrinter(LatexPrinter):
+        \"\"\"Print derivative of a function of symbols in a shorter form.
+        \"\"\"
+        def _print_Derivative(self, expr):
+            function, *vars = expr.args
+            if not isinstance(type(function), UndefinedFunction) or \\
+               not all(isinstance(i, Symbol) for i in vars):
+                return super()._print_Derivative(expr)
+
+            # If you want the printer to work correctly for nested
+            # expressions then use self._print() instead of str() or latex().
+            # See the example of nested modulo below in the custom printing
+            # method section.
+            return "{}_{{{}}}".format(
+                self._print(Symbol(function.func.__name__)),
+                            ''.join(self._print(i) for i in vars))
+
+
+    def print_my_latex(expr):
+        \"\"\" Most of the printers define their own wrappers for print().
+        These wrappers usually take printer settings. Our printer does not have
+        any settings.
+        \"\"\"
+        print(MyLatexPrinter().doprint(expr))
+
+
+    y = Symbol("y")
+    x = Symbol("x")
+    f = Function("f")
+    expr = f(x, y).diff(x, y)
+
+    # Print the expression using the normal latex printer and our custom
+    # printer.
+    print_latex(expr)
+    print_my_latex(expr)
+
+The output of the code above is::
+
+    \\frac{\\partial^{2}}{\\partial x\\partial y}  f{\\left(x,y \\right)}
+    f_{xy}
+
+.. _printer_method_example:
+
+Example of Custom Printing Method
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In the example below, the latex printing of the modulo operator is modified.
+This is done by overriding the method ``_latex`` of ``Mod``.
+
+>>> from sympy import Symbol, Mod, Integer, print_latex
+
+>>> # Always use printer._print()
+>>> class ModOp(Mod):
+...     def _latex(self, printer):
+...         a, b = [printer._print(i) for i in self.args]
+...         return r"\\operatorname{Mod}{\\left(%s, %s\\right)}" % (a, b)
+
+Comparing the output of our custom operator to the builtin one:
+
+>>> x = Symbol('x')
+>>> m = Symbol('m')
+>>> print_latex(Mod(x, m))
+x \\bmod m
+>>> print_latex(ModOp(x, m))
+\\operatorname{Mod}{\\left(x, m\\right)}
+
+Common mistakes
+~~~~~~~~~~~~~~~
+It's important to always use ``self._print(obj)`` to print subcomponents of
+an expression when customizing a printer. Mistakes include:
+
+1.  Using ``self.doprint(obj)`` instead:
+
+    >>> # This example does not work properly, as only the outermost call may use
+    >>> # doprint.
+    >>> class ModOpModeWrong(Mod):
+    ...     def _latex(self, printer):
+    ...         a, b = [printer.doprint(i) for i in self.args]
+    ...         return r"\\operatorname{Mod}{\\left(%s, %s\\right)}" % (a, b)
+
+    This fails when the ``mode`` argument is passed to the printer:
+
+    >>> print_latex(ModOp(x, m), mode='inline')  # ok
+    $\\operatorname{Mod}{\\left(x, m\\right)}$
+    >>> print_latex(ModOpModeWrong(x, m), mode='inline')  # bad
+    $\\operatorname{Mod}{\\left($x$, $m$\\right)}$
+
+2.  Using ``str(obj)`` instead:
+
+    >>> class ModOpNestedWrong(Mod):
+    ...     def _latex(self, printer):
+    ...         a, b = [str(i) for i in self.args]
+    ...         return r"\\operatorname{Mod}{\\left(%s, %s\\right)}" % (a, b)
+
+    This fails on nested objects:
+
+    >>> # Nested modulo.
+    >>> print_latex(ModOp(ModOp(x, m), Integer(7)))  # ok
+    \\operatorname{Mod}{\\left(\\operatorname{Mod}{\\left(x, m\\right)}, 7\\right)}
+    >>> print_latex(ModOpNestedWrong(ModOpNestedWrong(x, m), Integer(7)))  # bad
+    \\operatorname{Mod}{\\left(ModOpNestedWrong(x, m), 7\\right)}
+
+3.  Using ``LatexPrinter()._print(obj)`` instead.
+
+    >>> from sympy.printing.latex import LatexPrinter
+    >>> class ModOpSettingsWrong(Mod):
+    ...     def _latex(self, printer):
+    ...         a, b = [LatexPrinter()._print(i) for i in self.args]
+    ...         return r"\\operatorname{Mod}{\\left(%s, %s\\right)}" % (a, b)
+
+    This causes all the settings to be discarded in the subobjects. As an
+    example, the ``full_prec`` setting which shows floats to full precision is
+    ignored:
+
+    >>> from sympy import Float
+    >>> print_latex(ModOp(Float(1) * x, m), full_prec=True)  # ok
+    \\operatorname{Mod}{\\left(1.00000000000000 x, m\\right)}
+    >>> print_latex(ModOpSettingsWrong(Float(1) * x, m), full_prec=True)  # bad
+    \\operatorname{Mod}{\\left(1.0 x, m\\right)}
+
+"""
+
+from __future__ import annotations
+import sys
+from typing import Any, Type
+import inspect
+from contextlib import contextmanager
+from functools import cmp_to_key, update_wrapper
+
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+
+from sympy.core.function import AppliedUndef, UndefinedFunction, Function
+
+
+
+@contextmanager
+def printer_context(printer, **kwargs):
+    original = printer._context.copy()
+    try:
+        printer._context.update(kwargs)
+        yield
+    finally:
+        printer._context = original
+
+
+class Printer:
+    """ Generic printer
+
+    Its job is to provide infrastructure for implementing new printers easily.
+
+    If you want to define your custom Printer or your custom printing method
+    for your custom class then see the example above: printer_example_ .
+    """
+
+    _global_settings: dict[str, Any] = {}
+
+    _default_settings: dict[str, Any] = {}
+
+    printmethod = None  # type: str
+
+    @classmethod
+    def _get_initial_settings(cls):
+        settings = cls._default_settings.copy()
+        for key, val in cls._global_settings.items():
+            if key in cls._default_settings:
+                settings[key] = val
+        return settings
+
+    def __init__(self, settings=None):
+        self._str = str
+
+        self._settings = self._get_initial_settings()
+        self._context = {}  # mutable during printing
+
+        if settings is not None:
+            self._settings.update(settings)
+
+            if len(self._settings) > len(self._default_settings):
+                for key in self._settings:
+                    if key not in self._default_settings:
+                        raise TypeError("Unknown setting '%s'." % key)
+
+        # _print_level is the number of times self._print() was recursively
+        # called. See StrPrinter._print_Float() for an example of usage
+        self._print_level = 0
+
+    @classmethod
+    def set_global_settings(cls, **settings):
+        """Set system-wide printing settings. """
+        for key, val in settings.items():
+            if val is not None:
+                cls._global_settings[key] = val
+
+    @property
+    def order(self):
+        if 'order' in self._settings:
+            return self._settings['order']
+        else:
+            raise AttributeError("No order defined.")
+
+    def doprint(self, expr):
+        """Returns printer's representation for expr (as a string)"""
+        return self._str(self._print(expr))
+
+    def _print(self, expr, **kwargs) -> str:
+        """Internal dispatcher
+
+        Tries the following concepts to print an expression:
+            1. Let the object print itself if it knows how.
+            2. Take the best fitting method defined in the printer.
+            3. As fall-back use the emptyPrinter method for the printer.
+        """
+        self._print_level += 1
+        try:
+            # If the printer defines a name for a printing method
+            # (Printer.printmethod) and the object knows for itself how it
+            # should be printed, use that method.
+            if self.printmethod and hasattr(expr, self.printmethod):
+                if not (isinstance(expr, type) and issubclass(expr, Basic)):
+                    return getattr(expr, self.printmethod)(self, **kwargs)
+
+            # See if the class of expr is known, or if one of its super
+            # classes is known, and use that print function
+            # Exception: ignore the subclasses of Undefined, so that, e.g.,
+            # Function('gamma') does not get dispatched to _print_gamma
+            classes = type(expr).__mro__
+            if AppliedUndef in classes:
+                classes = classes[classes.index(AppliedUndef):]
+            if UndefinedFunction in classes:
+                classes = classes[classes.index(UndefinedFunction):]
+            # Another exception: if someone subclasses a known function, e.g.,
+            # gamma, and changes the name, then ignore _print_gamma
+            if Function in classes:
+                i = classes.index(Function)
+                classes = tuple(c for c in classes[:i] if \
+                    c.__name__ == classes[0].__name__ or \
+                    c.__name__.endswith("Base")) + classes[i:]
+            for cls in classes:
+                printmethodname = '_print_' + cls.__name__
+                printmethod = getattr(self, printmethodname, None)
+                if printmethod is not None:
+                    return printmethod(expr, **kwargs)
+            # Unknown object, fall back to the emptyPrinter.
+            return self.emptyPrinter(expr)
+        finally:
+            self._print_level -= 1
+
+    def emptyPrinter(self, expr):
+        return str(expr)
+
+    def _as_ordered_terms(self, expr, order=None):
+        """A compatibility function for ordering terms in Add. """
+        order = order or self.order
+
+        if order == 'old':
+            return sorted(Add.make_args(expr), key=cmp_to_key(Basic._compare_pretty))
+        elif order == 'none':
+            return list(expr.args)
+        else:
+            return expr.as_ordered_terms(order=order)
+
+
+class _PrintFunction:
+    """
+    Function wrapper to replace ``**settings`` in the signature with printer defaults
+    """
+    def __init__(self, f, print_cls: Type[Printer]):
+        # find all the non-setting arguments
+        params = list(inspect.signature(f).parameters.values())
+        assert params.pop(-1).kind == inspect.Parameter.VAR_KEYWORD
+        self.__other_params = params
+
+        self.__print_cls = print_cls
+        update_wrapper(self, f)
+
+    def __reduce__(self):
+        # Since this is used as a decorator, it replaces the original function.
+        # The default pickling will try to pickle self.__wrapped__ and fail
+        # because the wrapped function can't be retrieved by name.
+        return self.__wrapped__.__qualname__
+
+    def __call__(self, *args, **kwargs):
+        return self.__wrapped__(*args, **kwargs)
+
+    @property
+    def __signature__(self) -> inspect.Signature:
+        settings = self.__print_cls._get_initial_settings()
+        return inspect.Signature(
+            parameters=self.__other_params + [
+                inspect.Parameter(k, inspect.Parameter.KEYWORD_ONLY, default=v)
+                for k, v in settings.items()
+            ],
+            return_annotation=self.__wrapped__.__annotations__.get('return', inspect.Signature.empty)  # type:ignore
+        )
+
+
+def print_function(print_cls):
+    """ A decorator to replace kwargs with the printer settings in __signature__ """
+    def decorator(f):
+        if sys.version_info < (3, 9):
+            # We have to create a subclass so that `help` actually shows the docstring in older Python versions.
+            # IPython and Sphinx do not need this, only a raw Python console.
+            cls = type(f'{f.__qualname__}_PrintFunction', (_PrintFunction,), {"__doc__": f.__doc__})
+        else:
+            cls = _PrintFunction
+        return cls(f, print_cls)
+    return decorator

env-llmeval/lib/python3.10/site-packages/sympy/printing/pycode.py

@@ -0,0 +1,750 @@
+"""
+Python code printers
+
+This module contains Python code printers for plain Python as well as NumPy & SciPy enabled code.
+"""
+from collections import defaultdict
+from itertools import chain
+from sympy.core import S
+from sympy.core.mod import Mod
+from .precedence import precedence
+from .codeprinter import CodePrinter
+
+_kw = {
+    'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif',
+    'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in',
+    'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while',
+    'with', 'yield', 'None', 'False', 'nonlocal', 'True'
+}
+
+_known_functions = {
+    'Abs': 'abs',
+    'Min': 'min',
+    'Max': 'max',
+}
+_known_functions_math = {
+    'acos': 'acos',
+    'acosh': 'acosh',
+    'asin': 'asin',
+    'asinh': 'asinh',
+    'atan': 'atan',
+    'atan2': 'atan2',
+    'atanh': 'atanh',
+    'ceiling': 'ceil',
+    'cos': 'cos',
+    'cosh': 'cosh',
+    'erf': 'erf',
+    'erfc': 'erfc',
+    'exp': 'exp',
+    'expm1': 'expm1',
+    'factorial': 'factorial',
+    'floor': 'floor',
+    'gamma': 'gamma',
+    'hypot': 'hypot',
+    'loggamma': 'lgamma',
+    'log': 'log',
+    'ln': 'log',
+    'log10': 'log10',
+    'log1p': 'log1p',
+    'log2': 'log2',
+    'sin': 'sin',
+    'sinh': 'sinh',
+    'Sqrt': 'sqrt',
+    'tan': 'tan',
+    'tanh': 'tanh'
+}  # Not used from ``math``: [copysign isclose isfinite isinf isnan ldexp frexp pow modf
+# radians trunc fmod fsum gcd degrees fabs]
+_known_constants_math = {
+    'Exp1': 'e',
+    'Pi': 'pi',
+    'E': 'e',
+    'Infinity': 'inf',
+    'NaN': 'nan',
+    'ComplexInfinity': 'nan'
+}
+
+def _print_known_func(self, expr):
+    known = self.known_functions[expr.__class__.__name__]
+    return '{name}({args})'.format(name=self._module_format(known),
+                                   args=', '.join((self._print(arg) for arg in expr.args)))
+
+
+def _print_known_const(self, expr):
+    known = self.known_constants[expr.__class__.__name__]
+    return self._module_format(known)
+
+
+class AbstractPythonCodePrinter(CodePrinter):
+    printmethod = "_pythoncode"
+    language = "Python"
+    reserved_words = _kw
+    modules = None  # initialized to a set in __init__
+    tab = '    '
+    _kf = dict(chain(
+        _known_functions.items(),
+        [(k, 'math.' + v) for k, v in _known_functions_math.items()]
+    ))
+    _kc = {k: 'math.'+v for k, v in _known_constants_math.items()}
+    _operators = {'and': 'and', 'or': 'or', 'not': 'not'}
+    _default_settings = dict(
+        CodePrinter._default_settings,
+        user_functions={},
+        precision=17,
+        inline=True,
+        fully_qualified_modules=True,
+        contract=False,
+        standard='python3',
+    )
+
+    def __init__(self, settings=None):
+        super().__init__(settings)
+
+        # Python standard handler
+        std = self._settings['standard']
+        if std is None:
+            import sys
+            std = 'python{}'.format(sys.version_info.major)
+        if std != 'python3':
+            raise ValueError('Only Python 3 is supported.')
+        self.standard = std
+
+        self.module_imports = defaultdict(set)
+
+        # Known functions and constants handler
+        self.known_functions = dict(self._kf, **(settings or {}).get(
+            'user_functions', {}))
+        self.known_constants = dict(self._kc, **(settings or {}).get(
+            'user_constants', {}))
+
+    def _declare_number_const(self, name, value):
+        return "%s = %s" % (name, value)
+
+    def _module_format(self, fqn, register=True):
+        parts = fqn.split('.')
+        if register and len(parts) > 1:
+            self.module_imports['.'.join(parts[:-1])].add(parts[-1])
+
+        if self._settings['fully_qualified_modules']:
+            return fqn
+        else:
+            return fqn.split('(')[0].split('[')[0].split('.')[-1]
+
+    def _format_code(self, lines):
+        return lines
+
+    def _get_statement(self, codestring):
+        return "{}".format(codestring)
+
+    def _get_comment(self, text):
+        return "  # {}".format(text)
+
+    def _expand_fold_binary_op(self, op, args):
+        """
+        This method expands a fold on binary operations.
+
+        ``functools.reduce`` is an example of a folded operation.
+
+        For example, the expression
+
+        `A + B + C + D`
+
+        is folded into
+
+        `((A + B) + C) + D`
+        """
+        if len(args) == 1:
+            return self._print(args[0])
+        else:
+            return "%s(%s, %s)" % (
+                self._module_format(op),
+                self._expand_fold_binary_op(op, args[:-1]),
+                self._print(args[-1]),
+            )
+
+    def _expand_reduce_binary_op(self, op, args):
+        """
+        This method expands a reductin on binary operations.
+
+        Notice: this is NOT the same as ``functools.reduce``.
+
+        For example, the expression
+
+        `A + B + C + D`
+
+        is reduced into:
+
+        `(A + B) + (C + D)`
+        """
+        if len(args) == 1:
+            return self._print(args[0])
+        else:
+            N = len(args)
+            Nhalf = N // 2
+            return "%s(%s, %s)" % (
+                self._module_format(op),
+                self._expand_reduce_binary_op(args[:Nhalf]),
+                self._expand_reduce_binary_op(args[Nhalf:]),
+            )
+
+    def _print_NaN(self, expr):
+        return "float('nan')"
+
+    def _print_Infinity(self, expr):
+        return "float('inf')"
+
+    def _print_NegativeInfinity(self, expr):
+        return "float('-inf')"
+
+    def _print_ComplexInfinity(self, expr):
+        return self._print_NaN(expr)
+
+    def _print_Mod(self, expr):
+        PREC = precedence(expr)
+        return ('{} % {}'.format(*(self.parenthesize(x, PREC) for x in expr.args)))
+
+    def _print_Piecewise(self, expr):
+        result = []
+        i = 0
+        for arg in expr.args:
+            e = arg.expr
+            c = arg.cond
+            if i == 0:
+                result.append('(')
+            result.append('(')
+            result.append(self._print(e))
+            result.append(')')
+            result.append(' if ')
+            result.append(self._print(c))
+            result.append(' else ')
+            i += 1
+        result = result[:-1]
+        if result[-1] == 'True':
+            result = result[:-2]
+            result.append(')')
+        else:
+            result.append(' else None)')
+        return ''.join(result)
+
+    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 '({lhs} {op} {rhs})'.format(op=expr.rel_op, lhs=lhs, rhs=rhs)
+        return super()._print_Relational(expr)
+
+    def _print_ITE(self, expr):
+        from sympy.functions.elementary.piecewise import Piecewise
+        return self._print(expr.rewrite(Piecewise))
+
+    def _print_Sum(self, expr):
+        loops = (
+            'for {i} in range({a}, {b}+1)'.format(
+                i=self._print(i),
+                a=self._print(a),
+                b=self._print(b))
+            for i, a, b in expr.limits)
+        return '(builtins.sum({function} {loops}))'.format(
+            function=self._print(expr.function),
+            loops=' '.join(loops))
+
+    def _print_ImaginaryUnit(self, expr):
+        return '1j'
+
+    def _print_KroneckerDelta(self, expr):
+        a, b = expr.args
+
+        return '(1 if {a} == {b} else 0)'.format(
+            a = self._print(a),
+            b = self._print(b)
+        )
+
+    def _print_MatrixBase(self, expr):
+        name = expr.__class__.__name__
+        func = self.known_functions.get(name, name)
+        return "%s(%s)" % (func, self._print(expr.tolist()))
+
+    _print_SparseRepMatrix = \
+        _print_MutableSparseMatrix = \
+        _print_ImmutableSparseMatrix = \
+        _print_Matrix = \
+        _print_DenseMatrix = \
+        _print_MutableDenseMatrix = \
+        _print_ImmutableMatrix = \
+        _print_ImmutableDenseMatrix = \
+        lambda self, expr: self._print_MatrixBase(expr)
+
+    def _indent_codestring(self, codestring):
+        return '\n'.join([self.tab + line for line in codestring.split('\n')])
+
+    def _print_FunctionDefinition(self, fd):
+        body = '\n'.join((self._print(arg) for arg in fd.body))
+        return "def {name}({parameters}):\n{body}".format(
+            name=self._print(fd.name),
+            parameters=', '.join([self._print(var.symbol) for var in fd.parameters]),
+            body=self._indent_codestring(body)
+        )
+
+    def _print_While(self, whl):
+        body = '\n'.join((self._print(arg) for arg in whl.body))
+        return "while {cond}:\n{body}".format(
+            cond=self._print(whl.condition),
+            body=self._indent_codestring(body)
+        )
+
+    def _print_Declaration(self, decl):
+        return '%s = %s' % (
+            self._print(decl.variable.symbol),
+            self._print(decl.variable.value)
+        )
+
+    def _print_Return(self, ret):
+        arg, = ret.args
+        return 'return %s' % self._print(arg)
+
+    def _print_Print(self, prnt):
+        print_args = ', '.join((self._print(arg) for arg in prnt.print_args))
+        if prnt.format_string != None: # Must be '!= None', cannot be 'is not None'
+            print_args = '{} % ({})'.format(
+                self._print(prnt.format_string), print_args)
+        if prnt.file != None: # Must be '!= None', cannot be 'is not None'
+            print_args += ', file=%s' % self._print(prnt.file)
+
+        return 'print(%s)' % print_args
+
+    def _print_Stream(self, strm):
+        if str(strm.name) == 'stdout':
+            return self._module_format('sys.stdout')
+        elif str(strm.name) == 'stderr':
+            return self._module_format('sys.stderr')
+        else:
+            return self._print(strm.name)
+
+    def _print_NoneToken(self, arg):
+        return 'None'
+
+    def _hprint_Pow(self, expr, rational=False, sqrt='math.sqrt'):
+        """Printing helper function for ``Pow``
+
+        Notes
+        =====
+
+        This preprocesses the ``sqrt`` as math formatter and prints division
+
+        Examples
+        ========
+
+        >>> from sympy import sqrt
+        >>> from sympy.printing.pycode import PythonCodePrinter
+        >>> from sympy.abc import x
+
+        Python code printer automatically looks up ``math.sqrt``.
+
+        >>> printer = PythonCodePrinter()
+        >>> printer._hprint_Pow(sqrt(x), rational=True)
+        'x**(1/2)'
+        >>> printer._hprint_Pow(sqrt(x), rational=False)
+        'math.sqrt(x)'
+        >>> printer._hprint_Pow(1/sqrt(x), rational=True)
+        'x**(-1/2)'
+        >>> printer._hprint_Pow(1/sqrt(x), rational=False)
+        '1/math.sqrt(x)'
+        >>> printer._hprint_Pow(1/x, rational=False)
+        '1/x'
+        >>> printer._hprint_Pow(1/x, rational=True)
+        'x**(-1)'
+
+        Using sqrt from numpy or mpmath
+
+        >>> printer._hprint_Pow(sqrt(x), sqrt='numpy.sqrt')
+        'numpy.sqrt(x)'
+        >>> printer._hprint_Pow(sqrt(x), sqrt='mpmath.sqrt')
+        'mpmath.sqrt(x)'
+
+        See Also
+        ========
+
+        sympy.printing.str.StrPrinter._print_Pow
+        """
+        PREC = precedence(expr)
+
+        if expr.exp == S.Half and not rational:
+            func = self._module_format(sqrt)
+            arg = self._print(expr.base)
+            return '{func}({arg})'.format(func=func, arg=arg)
+
+        if expr.is_commutative and not rational:
+            if -expr.exp is S.Half:
+                func = self._module_format(sqrt)
+                num = self._print(S.One)
+                arg = self._print(expr.base)
+                return f"{num}/{func}({arg})"
+            if expr.exp is S.NegativeOne:
+                num = self._print(S.One)
+                arg = self.parenthesize(expr.base, PREC, strict=False)
+                return f"{num}/{arg}"
+
+
+        base_str = self.parenthesize(expr.base, PREC, strict=False)
+        exp_str = self.parenthesize(expr.exp, PREC, strict=False)
+        return "{}**{}".format(base_str, exp_str)
+
+
+class ArrayPrinter:
+
+    def _arrayify(self, indexed):
+        from sympy.tensor.array.expressions.from_indexed_to_array import convert_indexed_to_array
+        try:
+            return convert_indexed_to_array(indexed)
+        except Exception:
+            return indexed
+
+    def _get_einsum_string(self, subranks, contraction_indices):
+        letters = self._get_letter_generator_for_einsum()
+        contraction_string = ""
+        counter = 0
+        d = {j: min(i) for i in contraction_indices for j in i}
+        indices = []
+        for rank_arg in subranks:
+            lindices = []
+            for i in range(rank_arg):
+                if counter in d:
+                    lindices.append(d[counter])
+                else:
+                    lindices.append(counter)
+                counter += 1
+            indices.append(lindices)
+        mapping = {}
+        letters_free = []
+        letters_dum = []
+        for i in indices:
+            for j in i:
+                if j not in mapping:
+                    l = next(letters)
+                    mapping[j] = l
+                else:
+                    l = mapping[j]
+                contraction_string += l
+                if j in d:
+                    if l not in letters_dum:
+                        letters_dum.append(l)
+                else:
+                    letters_free.append(l)
+            contraction_string += ","
+        contraction_string = contraction_string[:-1]
+        return contraction_string, letters_free, letters_dum
+
+    def _get_letter_generator_for_einsum(self):
+        for i in range(97, 123):
+            yield chr(i)
+        for i in range(65, 91):
+            yield chr(i)
+        raise ValueError("out of letters")
+
+    def _print_ArrayTensorProduct(self, expr):
+        letters = self._get_letter_generator_for_einsum()
+        contraction_string = ",".join(["".join([next(letters) for j in range(i)]) for i in expr.subranks])
+        return '%s("%s", %s)' % (
+                self._module_format(self._module + "." + self._einsum),
+                contraction_string,
+                ", ".join([self._print(arg) for arg in expr.args])
+        )
+
+    def _print_ArrayContraction(self, expr):
+        from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct
+        base = expr.expr
+        contraction_indices = expr.contraction_indices
+
+        if isinstance(base, ArrayTensorProduct):
+            elems = ",".join(["%s" % (self._print(arg)) for arg in base.args])
+            ranks = base.subranks
+        else:
+            elems = self._print(base)
+            ranks = [len(base.shape)]
+
+        contraction_string, letters_free, letters_dum = self._get_einsum_string(ranks, contraction_indices)
+
+        if not contraction_indices:
+            return self._print(base)
+        if isinstance(base, ArrayTensorProduct):
+            elems = ",".join(["%s" % (self._print(arg)) for arg in base.args])
+        else:
+            elems = self._print(base)
+        return "%s(\"%s\", %s)" % (
+            self._module_format(self._module + "." + self._einsum),
+            "{}->{}".format(contraction_string, "".join(sorted(letters_free))),
+            elems,
+        )
+
+    def _print_ArrayDiagonal(self, expr):
+        from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct
+        diagonal_indices = list(expr.diagonal_indices)
+        if isinstance(expr.expr, ArrayTensorProduct):
+            subranks = expr.expr.subranks
+            elems = expr.expr.args
+        else:
+            subranks = expr.subranks
+            elems = [expr.expr]
+        diagonal_string, letters_free, letters_dum = self._get_einsum_string(subranks, diagonal_indices)
+        elems = [self._print(i) for i in elems]
+        return '%s("%s", %s)' % (
+            self._module_format(self._module + "." + self._einsum),
+            "{}->{}".format(diagonal_string, "".join(letters_free+letters_dum)),
+            ", ".join(elems)
+        )
+
+    def _print_PermuteDims(self, expr):
+        return "%s(%s, %s)" % (
+            self._module_format(self._module + "." + self._transpose),
+            self._print(expr.expr),
+            self._print(expr.permutation.array_form),
+        )
+
+    def _print_ArrayAdd(self, expr):
+        return self._expand_fold_binary_op(self._module + "." + self._add, expr.args)
+
+    def _print_OneArray(self, expr):
+        return "%s((%s,))" % (
+            self._module_format(self._module+ "." + self._ones),
+            ','.join(map(self._print,expr.args))
+        )
+
+    def _print_ZeroArray(self, expr):
+        return "%s((%s,))" % (
+            self._module_format(self._module+ "." + self._zeros),
+            ','.join(map(self._print,expr.args))
+        )
+
+    def _print_Assignment(self, expr):
+        #XXX: maybe this needs to happen at a higher level e.g. at _print or
+        #doprint?
+        lhs = self._print(self._arrayify(expr.lhs))
+        rhs = self._print(self._arrayify(expr.rhs))
+        return "%s = %s" % ( lhs, rhs )
+
+    def _print_IndexedBase(self, expr):
+        return self._print_ArraySymbol(expr)
+
+
+class PythonCodePrinter(AbstractPythonCodePrinter):
+
+    def _print_sign(self, e):
+        return '(0.0 if {e} == 0 else {f}(1, {e}))'.format(
+            f=self._module_format('math.copysign'), e=self._print(e.args[0]))
+
+    def _print_Not(self, expr):
+        PREC = precedence(expr)
+        return self._operators['not'] + self.parenthesize(expr.args[0], PREC)
+
+    def _print_Indexed(self, expr):
+        base = expr.args[0]
+        index = expr.args[1:]
+        return "{}[{}]".format(str(base), ", ".join([self._print(ind) for ind in index]))
+
+    def _print_Pow(self, expr, rational=False):
+        return self._hprint_Pow(expr, rational=rational)
+
+    def _print_Rational(self, expr):
+        return '{}/{}'.format(expr.p, expr.q)
+
+    def _print_Half(self, expr):
+        return self._print_Rational(expr)
+
+    def _print_frac(self, expr):
+        return self._print_Mod(Mod(expr.args[0], 1))
+
+    def _print_Symbol(self, expr):
+
+        name = super()._print_Symbol(expr)
+
+        if name in self.reserved_words:
+            if self._settings['error_on_reserved']:
+                msg = ('This expression includes the symbol "{}" which is a '
+                       'reserved keyword in this language.')
+                raise ValueError(msg.format(name))
+            return name + self._settings['reserved_word_suffix']
+        elif '{' in name:   # Remove curly braces from subscripted variables
+            return name.replace('{', '').replace('}', '')
+        else:
+            return name
+
+    _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 k in PythonCodePrinter._kf:
+    setattr(PythonCodePrinter, '_print_%s' % k, _print_known_func)
+
+for k in _known_constants_math:
+    setattr(PythonCodePrinter, '_print_%s' % k, _print_known_const)
+
+
+def pycode(expr, **settings):
+    """ Converts an expr to a string of Python code
+
+    Parameters
+    ==========
+
+    expr : Expr
+        A SymPy expression.
+    fully_qualified_modules : bool
+        Whether or not to write out full module names of functions
+        (``math.sin`` vs. ``sin``). default: ``True``.
+    standard : str or None, optional
+        Only 'python3' (default) is supported.
+        This parameter may be removed in the future.
+
+    Examples
+    ========
+
+    >>> from sympy import pycode, tan, Symbol
+    >>> pycode(tan(Symbol('x')) + 1)
+    'math.tan(x) + 1'
+
+    """
+    return PythonCodePrinter(settings).doprint(expr)
+
+
+_not_in_mpmath = 'log1p log2'.split()
+_in_mpmath = [(k, v) for k, v in _known_functions_math.items() if k not in _not_in_mpmath]
+_known_functions_mpmath = dict(_in_mpmath, **{
+    'beta': 'beta',
+    'frac': 'frac',
+    'fresnelc': 'fresnelc',
+    'fresnels': 'fresnels',
+    'sign': 'sign',
+    'loggamma': 'loggamma',
+    'hyper': 'hyper',
+    'meijerg': 'meijerg',
+    'besselj': 'besselj',
+    'bessely': 'bessely',
+    'besseli': 'besseli',
+    'besselk': 'besselk',
+})
+_known_constants_mpmath = {
+    'Exp1': 'e',
+    'Pi': 'pi',
+    'GoldenRatio': 'phi',
+    'EulerGamma': 'euler',
+    'Catalan': 'catalan',
+    'NaN': 'nan',
+    'Infinity': 'inf',
+    'NegativeInfinity': 'ninf'
+}
+
+
+def _unpack_integral_limits(integral_expr):
+    """ helper function for _print_Integral that
+        - accepts an Integral expression
+        - returns a tuple of
+           - a list variables of integration
+           - a list of tuples of the upper and lower limits of integration
+    """
+    integration_vars = []
+    limits = []
+    for integration_range in integral_expr.limits:
+        if len(integration_range) == 3:
+            integration_var, lower_limit, upper_limit = integration_range
+        else:
+            raise NotImplementedError("Only definite integrals are supported")
+        integration_vars.append(integration_var)
+        limits.append((lower_limit, upper_limit))
+    return integration_vars, limits
+
+
+class MpmathPrinter(PythonCodePrinter):
+    """
+    Lambda printer for mpmath which maintains precision for floats
+    """
+    printmethod = "_mpmathcode"
+
+    language = "Python with mpmath"
+
+    _kf = dict(chain(
+        _known_functions.items(),
+        [(k, 'mpmath.' + v) for k, v in _known_functions_mpmath.items()]
+    ))
+    _kc = {k: 'mpmath.'+v for k, v in _known_constants_mpmath.items()}
+
+    def _print_Float(self, e):
+        # XXX: This does not handle setting mpmath.mp.dps. It is assumed that
+        # the caller of the lambdified function will have set it to sufficient
+        # precision to match the Floats in the expression.
+
+        # Remove 'mpz' if gmpy is installed.
+        args = str(tuple(map(int, e._mpf_)))
+        return '{func}({args})'.format(func=self._module_format('mpmath.mpf'), args=args)
+
+
+    def _print_Rational(self, e):
+        return "{func}({p})/{func}({q})".format(
+            func=self._module_format('mpmath.mpf'),
+            q=self._print(e.q),
+            p=self._print(e.p)
+        )
+
+    def _print_Half(self, e):
+        return self._print_Rational(e)
+
+    def _print_uppergamma(self, e):
+        return "{}({}, {}, {})".format(
+            self._module_format('mpmath.gammainc'),
+            self._print(e.args[0]),
+            self._print(e.args[1]),
+            self._module_format('mpmath.inf'))
+
+    def _print_lowergamma(self, e):
+        return "{}({}, 0, {})".format(
+            self._module_format('mpmath.gammainc'),
+            self._print(e.args[0]),
+            self._print(e.args[1]))
+
+    def _print_log2(self, e):
+        return '{0}({1})/{0}(2)'.format(
+            self._module_format('mpmath.log'), self._print(e.args[0]))
+
+    def _print_log1p(self, e):
+        return '{}({})'.format(
+            self._module_format('mpmath.log1p'), self._print(e.args[0]))
+
+    def _print_Pow(self, expr, rational=False):
+        return self._hprint_Pow(expr, rational=rational, sqrt='mpmath.sqrt')
+
+    def _print_Integral(self, e):
+        integration_vars, limits = _unpack_integral_limits(e)
+
+        return "{}(lambda {}: {}, {})".format(
+                self._module_format("mpmath.quad"),
+                ", ".join(map(self._print, integration_vars)),
+                self._print(e.args[0]),
+                ", ".join("(%s, %s)" % tuple(map(self._print, l)) for l in limits))
+
+
+for k in MpmathPrinter._kf:
+    setattr(MpmathPrinter, '_print_%s' % k, _print_known_func)
+
+for k in _known_constants_mpmath:
+    setattr(MpmathPrinter, '_print_%s' % k, _print_known_const)
+
+
+class SymPyPrinter(AbstractPythonCodePrinter):
+
+    language = "Python with SymPy"
+
+    def _print_Function(self, expr):
+        mod = expr.func.__module__ or ''
+        return '%s(%s)' % (self._module_format(mod + ('.' if mod else '') + expr.func.__name__),
+                           ', '.join((self._print(arg) for arg in expr.args)))
+
+    def _print_Pow(self, expr, rational=False):
+        return self._hprint_Pow(expr, rational=rational, sqrt='sympy.sqrt')

env-llmeval/lib/python3.10/site-packages/sympy/printing/python.py

@@ -0,0 +1,93 @@
+import keyword as kw
+import sympy
+from .repr import ReprPrinter
+from .str import StrPrinter
+
+# A list of classes that should be printed using StrPrinter
+STRPRINT = ("Add", "Infinity", "Integer", "Mul", "NegativeInfinity",
+            "Pow", "Zero")
+
+
+class PythonPrinter(ReprPrinter, StrPrinter):
+    """A printer which converts an expression into its Python interpretation."""
+
+    def __init__(self, settings=None):
+        super().__init__(settings)
+        self.symbols = []
+        self.functions = []
+
+        # Create print methods for classes that should use StrPrinter instead
+        # of ReprPrinter.
+        for name in STRPRINT:
+            f_name = "_print_%s" % name
+            f = getattr(StrPrinter, f_name)
+            setattr(PythonPrinter, f_name, f)
+
+    def _print_Function(self, expr):
+        func = expr.func.__name__
+        if not hasattr(sympy, func) and func not in self.functions:
+            self.functions.append(func)
+        return StrPrinter._print_Function(self, expr)
+
+    # procedure (!) for defining symbols which have be defined in print_python()
+    def _print_Symbol(self, expr):
+        symbol = self._str(expr)
+        if symbol not in self.symbols:
+            self.symbols.append(symbol)
+        return StrPrinter._print_Symbol(self, expr)
+
+    def _print_module(self, expr):
+        raise ValueError('Modules in the expression are unacceptable')
+
+
+def python(expr, **settings):
+    """Return Python interpretation of passed expression
+    (can be passed to the exec() function without any modifications)"""
+
+    printer = PythonPrinter(settings)
+    exprp = printer.doprint(expr)
+
+    result = ''
+    # Returning found symbols and functions
+    renamings = {}
+    for symbolname in printer.symbols:
+        # Remove curly braces from subscripted variables
+        if '{' in symbolname:
+            newsymbolname = symbolname.replace('{', '').replace('}', '')
+            renamings[sympy.Symbol(symbolname)] = newsymbolname
+        else:
+            newsymbolname = symbolname
+
+        # Escape symbol names that are reserved Python keywords
+        if kw.iskeyword(newsymbolname):
+            while True:
+                newsymbolname += "_"
+                if (newsymbolname not in printer.symbols and
+                        newsymbolname not in printer.functions):
+                    renamings[sympy.Symbol(
+                        symbolname)] = sympy.Symbol(newsymbolname)
+                    break
+        result += newsymbolname + ' = Symbol(\'' + symbolname + '\')\n'
+
+    for functionname in printer.functions:
+        newfunctionname = functionname
+        # Escape function names that are reserved Python keywords
+        if kw.iskeyword(newfunctionname):
+            while True:
+                newfunctionname += "_"
+                if (newfunctionname not in printer.symbols and
+                        newfunctionname not in printer.functions):
+                    renamings[sympy.Function(
+                        functionname)] = sympy.Function(newfunctionname)
+                    break
+        result += newfunctionname + ' = Function(\'' + functionname + '\')\n'
+
+    if renamings:
+        exprp = expr.subs(renamings)
+    result += 'e = ' + printer._str(exprp)
+    return result
+
+
+def print_python(expr, **settings):
+    """Print output of python() function"""
+    print(python(expr, **settings))

env-llmeval/lib/python3.10/site-packages/sympy/printing/repr.py

@@ -0,0 +1,342 @@
+"""
+A Printer for generating executable code.
+
+The most important function here is srepr that returns a string so that the
+relation eval(srepr(expr))=expr holds in an appropriate environment.
+"""
+
+from __future__ import annotations
+from typing import Any
+
+from sympy.core.function import AppliedUndef
+from sympy.core.mul import Mul
+from mpmath.libmp import repr_dps, to_str as mlib_to_str
+
+from .printer import Printer, print_function
+
+
+class ReprPrinter(Printer):
+    printmethod = "_sympyrepr"
+
+    _default_settings: dict[str, Any] = {
+        "order": None,
+        "perm_cyclic" : True,
+    }
+
+    def reprify(self, args, sep):
+        """
+        Prints each item in `args` and joins them with `sep`.
+        """
+        return sep.join([self.doprint(item) for item in args])
+
+    def emptyPrinter(self, expr):
+        """
+        The fallback printer.
+        """
+        if isinstance(expr, str):
+            return expr
+        elif hasattr(expr, "__srepr__"):
+            return expr.__srepr__()
+        elif hasattr(expr, "args") and hasattr(expr.args, "__iter__"):
+            l = []
+            for o in expr.args:
+                l.append(self._print(o))
+            return expr.__class__.__name__ + '(%s)' % ', '.join(l)
+        elif hasattr(expr, "__module__") and hasattr(expr, "__name__"):
+            return "<'%s.%s'>" % (expr.__module__, expr.__name__)
+        else:
+            return str(expr)
+
+    def _print_Add(self, expr, order=None):
+        args = self._as_ordered_terms(expr, order=order)
+        args = map(self._print, args)
+        clsname = type(expr).__name__
+        return clsname + "(%s)" % ", ".join(args)
+
+    def _print_Cycle(self, expr):
+        return expr.__repr__()
+
+    def _print_Permutation(self, expr):
+        from sympy.combinatorics.permutations import Permutation, Cycle
+        from sympy.utilities.exceptions import sympy_deprecation_warning
+
+        perm_cyclic = Permutation.print_cyclic
+        if perm_cyclic is not None:
+            sympy_deprecation_warning(
+                f"""
+                Setting Permutation.print_cyclic is deprecated. Instead use
+                init_printing(perm_cyclic={perm_cyclic}).
+                """,
+                deprecated_since_version="1.6",
+                active_deprecations_target="deprecated-permutation-print_cyclic",
+                stacklevel=7,
+            )
+        else:
+            perm_cyclic = self._settings.get("perm_cyclic", True)
+
+        if perm_cyclic:
+            if not expr.size:
+                return 'Permutation()'
+            # before taking Cycle notation, see if the last element is
+            # a singleton and move it to the head of the string
+            s = Cycle(expr)(expr.size - 1).__repr__()[len('Cycle'):]
+            last = s.rfind('(')
+            if not last == 0 and ',' not in s[last:]:
+                s = s[last:] + s[:last]
+            return 'Permutation%s' %s
+        else:
+            s = expr.support()
+            if not s:
+                if expr.size < 5:
+                    return 'Permutation(%s)' % str(expr.array_form)
+                return 'Permutation([], size=%s)' % expr.size
+            trim = str(expr.array_form[:s[-1] + 1]) + ', size=%s' % expr.size
+            use = full = str(expr.array_form)
+            if len(trim) < len(full):
+                use = trim
+            return 'Permutation(%s)' % use
+
+    def _print_Function(self, expr):
+        r = self._print(expr.func)
+        r += '(%s)' % ', '.join([self._print(a) for a in expr.args])
+        return r
+
+    def _print_Heaviside(self, expr):
+        # Same as _print_Function but uses pargs to suppress default value for
+        # 2nd arg.
+        r = self._print(expr.func)
+        r += '(%s)' % ', '.join([self._print(a) for a in expr.pargs])
+        return r
+
+    def _print_FunctionClass(self, expr):
+        if issubclass(expr, AppliedUndef):
+            return 'Function(%r)' % (expr.__name__)
+        else:
+            return expr.__name__
+
+    def _print_Half(self, expr):
+        return 'Rational(1, 2)'
+
+    def _print_RationalConstant(self, expr):
+        return str(expr)
+
+    def _print_AtomicExpr(self, expr):
+        return str(expr)
+
+    def _print_NumberSymbol(self, expr):
+        return str(expr)
+
+    def _print_Integer(self, expr):
+        return 'Integer(%i)' % expr.p
+
+    def _print_Complexes(self, expr):
+        return 'Complexes'
+
+    def _print_Integers(self, expr):
+        return 'Integers'
+
+    def _print_Naturals(self, expr):
+        return 'Naturals'
+
+    def _print_Naturals0(self, expr):
+        return 'Naturals0'
+
+    def _print_Rationals(self, expr):
+        return 'Rationals'
+
+    def _print_Reals(self, expr):
+        return 'Reals'
+
+    def _print_EmptySet(self, expr):
+        return 'EmptySet'
+
+    def _print_UniversalSet(self, expr):
+        return 'UniversalSet'
+
+    def _print_EmptySequence(self, expr):
+        return 'EmptySequence'
+
+    def _print_list(self, expr):
+        return "[%s]" % self.reprify(expr, ", ")
+
+    def _print_dict(self, expr):
+        sep = ", "
+        dict_kvs = ["%s: %s" % (self.doprint(key), self.doprint(value)) for key, value in expr.items()]
+        return "{%s}" % sep.join(dict_kvs)
+
+    def _print_set(self, expr):
+        if not expr:
+            return "set()"
+        return "{%s}" % self.reprify(expr, ", ")
+
+    def _print_MatrixBase(self, expr):
+        # special case for some empty matrices
+        if (expr.rows == 0) ^ (expr.cols == 0):
+            return '%s(%s, %s, %s)' % (expr.__class__.__name__,
+                                       self._print(expr.rows),
+                                       self._print(expr.cols),
+                                       self._print([]))
+        l = []
+        for i in range(expr.rows):
+            l.append([])
+            for j in range(expr.cols):
+                l[-1].append(expr[i, j])
+        return '%s(%s)' % (expr.__class__.__name__, self._print(l))
+
+    def _print_BooleanTrue(self, expr):
+        return "true"
+
+    def _print_BooleanFalse(self, expr):
+        return "false"
+
+    def _print_NaN(self, expr):
+        return "nan"
+
+    def _print_Mul(self, expr, order=None):
+        if self.order not in ('old', 'none'):
+            args = expr.as_ordered_factors()
+        else:
+            # use make_args in case expr was something like -x -> x
+            args = Mul.make_args(expr)
+
+        args = map(self._print, args)
+        clsname = type(expr).__name__
+        return clsname + "(%s)" % ", ".join(args)
+
+    def _print_Rational(self, expr):
+        return 'Rational(%s, %s)' % (self._print(expr.p), self._print(expr.q))
+
+    def _print_PythonRational(self, expr):
+        return "%s(%d, %d)" % (expr.__class__.__name__, expr.p, expr.q)
+
+    def _print_Fraction(self, expr):
+        return 'Fraction(%s, %s)' % (self._print(expr.numerator), self._print(expr.denominator))
+
+    def _print_Float(self, expr):
+        r = mlib_to_str(expr._mpf_, repr_dps(expr._prec))
+        return "%s('%s', precision=%i)" % (expr.__class__.__name__, r, expr._prec)
+
+    def _print_Sum2(self, expr):
+        return "Sum2(%s, (%s, %s, %s))" % (self._print(expr.f), self._print(expr.i),
+                                           self._print(expr.a), self._print(expr.b))
+
+    def _print_Str(self, s):
+        return "%s(%s)" % (s.__class__.__name__, self._print(s.name))
+
+    def _print_Symbol(self, expr):
+        d = expr._assumptions_orig
+        # print the dummy_index like it was an assumption
+        if expr.is_Dummy:
+            d['dummy_index'] = expr.dummy_index
+
+        if d == {}:
+            return "%s(%s)" % (expr.__class__.__name__, self._print(expr.name))
+        else:
+            attr = ['%s=%s' % (k, v) for k, v in d.items()]
+            return "%s(%s, %s)" % (expr.__class__.__name__,
+                                   self._print(expr.name), ', '.join(attr))
+
+    def _print_CoordinateSymbol(self, expr):
+        d = expr._assumptions.generator
+
+        if d == {}:
+            return "%s(%s, %s)" % (
+                expr.__class__.__name__,
+                self._print(expr.coord_sys),
+                self._print(expr.index)
+            )
+        else:
+            attr = ['%s=%s' % (k, v) for k, v in d.items()]
+            return "%s(%s, %s, %s)" % (
+                expr.__class__.__name__,
+                self._print(expr.coord_sys),
+                self._print(expr.index),
+                ', '.join(attr)
+            )
+
+    def _print_Predicate(self, expr):
+        return "Q.%s" % expr.name
+
+    def _print_AppliedPredicate(self, expr):
+        # will be changed to just expr.args when args overriding is removed
+        args = expr._args
+        return "%s(%s)" % (expr.__class__.__name__, self.reprify(args, ", "))
+
+    def _print_str(self, expr):
+        return repr(expr)
+
+    def _print_tuple(self, expr):
+        if len(expr) == 1:
+            return "(%s,)" % self._print(expr[0])
+        else:
+            return "(%s)" % self.reprify(expr, ", ")
+
+    def _print_WildFunction(self, expr):
+        return "%s('%s')" % (expr.__class__.__name__, expr.name)
+
+    def _print_AlgebraicNumber(self, expr):
+        return "%s(%s, %s)" % (expr.__class__.__name__,
+            self._print(expr.root), self._print(expr.coeffs()))
+
+    def _print_PolyRing(self, ring):
+        return "%s(%s, %s, %s)" % (ring.__class__.__name__,
+            self._print(ring.symbols), self._print(ring.domain), self._print(ring.order))
+
+    def _print_FracField(self, field):
+        return "%s(%s, %s, %s)" % (field.__class__.__name__,
+            self._print(field.symbols), self._print(field.domain), self._print(field.order))
+
+    def _print_PolyElement(self, poly):
+        terms = list(poly.terms())
+        terms.sort(key=poly.ring.order, reverse=True)
+        return "%s(%s, %s)" % (poly.__class__.__name__, self._print(poly.ring), self._print(terms))
+
+    def _print_FracElement(self, frac):
+        numer_terms = list(frac.numer.terms())
+        numer_terms.sort(key=frac.field.order, reverse=True)
+        denom_terms = list(frac.denom.terms())
+        denom_terms.sort(key=frac.field.order, reverse=True)
+        numer = self._print(numer_terms)
+        denom = self._print(denom_terms)
+        return "%s(%s, %s, %s)" % (frac.__class__.__name__, self._print(frac.field), numer, denom)
+
+    def _print_FractionField(self, domain):
+        cls = domain.__class__.__name__
+        field = self._print(domain.field)
+        return "%s(%s)" % (cls, field)
+
+    def _print_PolynomialRingBase(self, ring):
+        cls = ring.__class__.__name__
+        dom = self._print(ring.domain)
+        gens = ', '.join(map(self._print, ring.gens))
+        order = str(ring.order)
+        if order != ring.default_order:
+            orderstr = ", order=" + order
+        else:
+            orderstr = ""
+        return "%s(%s, %s%s)" % (cls, dom, gens, orderstr)
+
+    def _print_DMP(self, p):
+        cls = p.__class__.__name__
+        rep = self._print(p.rep)
+        dom = self._print(p.dom)
+        if p.ring is not None:
+            ringstr = ", ring=" + self._print(p.ring)
+        else:
+            ringstr = ""
+        return "%s(%s, %s%s)" % (cls, rep, dom, ringstr)
+
+    def _print_MonogenicFiniteExtension(self, ext):
+        # The expanded tree shown by srepr(ext.modulus)
+        # is not practical.
+        return "FiniteExtension(%s)" % str(ext.modulus)
+
+    def _print_ExtensionElement(self, f):
+        rep = self._print(f.rep)
+        ext = self._print(f.ext)
+        return "ExtElem(%s, %s)" % (rep, ext)
+
+@print_function(ReprPrinter)
+def srepr(expr, **settings):
+    """return expr in repr form"""
+    return ReprPrinter(settings).doprint(expr)

env-llmeval/lib/python3.10/site-packages/sympy/printing/str.py

@@ -0,0 +1,1027 @@
+"""
+A Printer for generating readable representation of most SymPy classes.
+"""
+
+from __future__ import annotations
+from typing import Any
+
+from sympy.core import S, Rational, Pow, Basic, Mul, Number
+from sympy.core.mul import _keep_coeff
+from sympy.core.relational import Relational
+from sympy.core.sorting import default_sort_key
+from sympy.core.sympify import SympifyError
+from sympy.utilities.iterables import sift
+from .precedence import precedence, PRECEDENCE
+from .printer import Printer, print_function
+
+from mpmath.libmp import prec_to_dps, to_str as mlib_to_str
+
+
+class StrPrinter(Printer):
+    printmethod = "_sympystr"
+    _default_settings: dict[str, Any] = {
+        "order": None,
+        "full_prec": "auto",
+        "sympy_integers": False,
+        "abbrev": False,
+        "perm_cyclic": True,
+        "min": None,
+        "max": None,
+    }
+
+    _relationals: dict[str, str] = {}
+
+    def parenthesize(self, item, level, strict=False):
+        if (precedence(item) < level) or ((not strict) and precedence(item) <= level):
+            return "(%s)" % self._print(item)
+        else:
+            return self._print(item)
+
+    def stringify(self, args, sep, level=0):
+        return sep.join([self.parenthesize(item, level) for item in args])
+
+    def emptyPrinter(self, expr):
+        if isinstance(expr, str):
+            return expr
+        elif isinstance(expr, Basic):
+            return repr(expr)
+        else:
+            return str(expr)
+
+    def _print_Add(self, expr, order=None):
+        terms = self._as_ordered_terms(expr, order=order)
+
+        prec = precedence(expr)
+        l = []
+        for term in terms:
+            t = self._print(term)
+            if t.startswith('-') and not term.is_Add:
+                sign = "-"
+                t = t[1:]
+            else:
+                sign = "+"
+            if precedence(term) < prec or term.is_Add:
+                l.extend([sign, "(%s)" % t])
+            else:
+                l.extend([sign, t])
+        sign = l.pop(0)
+        if sign == '+':
+            sign = ""
+        return sign + ' '.join(l)
+
+    def _print_BooleanTrue(self, expr):
+        return "True"
+
+    def _print_BooleanFalse(self, expr):
+        return "False"
+
+    def _print_Not(self, expr):
+        return '~%s' %(self.parenthesize(expr.args[0],PRECEDENCE["Not"]))
+
+    def _print_And(self, expr):
+        args = list(expr.args)
+        for j, i in enumerate(args):
+            if isinstance(i, Relational) and (
+                    i.canonical.rhs is S.NegativeInfinity):
+                args.insert(0, args.pop(j))
+        return self.stringify(args, " & ", PRECEDENCE["BitwiseAnd"])
+
+    def _print_Or(self, expr):
+        return self.stringify(expr.args, " | ", PRECEDENCE["BitwiseOr"])
+
+    def _print_Xor(self, expr):
+        return self.stringify(expr.args, " ^ ", PRECEDENCE["BitwiseXor"])
+
+    def _print_AppliedPredicate(self, expr):
+        return '%s(%s)' % (
+            self._print(expr.function), self.stringify(expr.arguments, ", "))
+
+    def _print_Basic(self, expr):
+        l = [self._print(o) for o in expr.args]
+        return expr.__class__.__name__ + "(%s)" % ", ".join(l)
+
+    def _print_BlockMatrix(self, B):
+        if B.blocks.shape == (1, 1):
+            self._print(B.blocks[0, 0])
+        return self._print(B.blocks)
+
+    def _print_Catalan(self, expr):
+        return 'Catalan'
+
+    def _print_ComplexInfinity(self, expr):
+        return 'zoo'
+
+    def _print_ConditionSet(self, s):
+        args = tuple([self._print(i) for i in (s.sym, s.condition)])
+        if s.base_set is S.UniversalSet:
+            return 'ConditionSet(%s, %s)' % args
+        args += (self._print(s.base_set),)
+        return 'ConditionSet(%s, %s, %s)' % args
+
+    def _print_Derivative(self, expr):
+        dexpr = expr.expr
+        dvars = [i[0] if i[1] == 1 else i for i in expr.variable_count]
+        return 'Derivative(%s)' % ", ".join((self._print(arg) for arg in [dexpr] + dvars))
+
+    def _print_dict(self, d):
+        keys = sorted(d.keys(), key=default_sort_key)
+        items = []
+
+        for key in keys:
+            item = "%s: %s" % (self._print(key), self._print(d[key]))
+            items.append(item)
+
+        return "{%s}" % ", ".join(items)
+
+    def _print_Dict(self, expr):
+        return self._print_dict(expr)
+
+    def _print_RandomDomain(self, d):
+        if hasattr(d, 'as_boolean'):
+            return 'Domain: ' + self._print(d.as_boolean())
+        elif hasattr(d, 'set'):
+            return ('Domain: ' + self._print(d.symbols) + ' in ' +
+                    self._print(d.set))
+        else:
+            return 'Domain on ' + self._print(d.symbols)
+
+    def _print_Dummy(self, expr):
+        return '_' + expr.name
+
+    def _print_EulerGamma(self, expr):
+        return 'EulerGamma'
+
+    def _print_Exp1(self, expr):
+        return 'E'
+
+    def _print_ExprCondPair(self, expr):
+        return '(%s, %s)' % (self._print(expr.expr), self._print(expr.cond))
+
+    def _print_Function(self, expr):
+        return expr.func.__name__ + "(%s)" % self.stringify(expr.args, ", ")
+
+    def _print_GoldenRatio(self, expr):
+        return 'GoldenRatio'
+
+    def _print_Heaviside(self, expr):
+        # Same as _print_Function but uses pargs to suppress default 1/2 for
+        # 2nd args
+        return expr.func.__name__ + "(%s)" % self.stringify(expr.pargs, ", ")
+
+    def _print_TribonacciConstant(self, expr):
+        return 'TribonacciConstant'
+
+    def _print_ImaginaryUnit(self, expr):
+        return 'I'
+
+    def _print_Infinity(self, expr):
+        return 'oo'
+
+    def _print_Integral(self, expr):
+        def _xab_tostr(xab):
+            if len(xab) == 1:
+                return self._print(xab[0])
+            else:
+                return self._print((xab[0],) + tuple(xab[1:]))
+        L = ', '.join([_xab_tostr(l) for l in expr.limits])
+        return 'Integral(%s, %s)' % (self._print(expr.function), L)
+
+    def _print_Interval(self, i):
+        fin =  'Interval{m}({a}, {b})'
+        a, b, l, r = i.args
+        if a.is_infinite and b.is_infinite:
+            m = ''
+        elif a.is_infinite and not r:
+            m = ''
+        elif b.is_infinite and not l:
+            m = ''
+        elif not l and not r:
+            m = ''
+        elif l and r:
+            m = '.open'
+        elif l:
+            m = '.Lopen'
+        else:
+            m = '.Ropen'
+        return fin.format(**{'a': a, 'b': b, 'm': m})
+
+    def _print_AccumulationBounds(self, i):
+        return "AccumBounds(%s, %s)" % (self._print(i.min),
+                                        self._print(i.max))
+
+    def _print_Inverse(self, I):
+        return "%s**(-1)" % self.parenthesize(I.arg, PRECEDENCE["Pow"])
+
+    def _print_Lambda(self, obj):
+        expr = obj.expr
+        sig = obj.signature
+        if len(sig) == 1 and sig[0].is_symbol:
+            sig = sig[0]
+        return "Lambda(%s, %s)" % (self._print(sig), self._print(expr))
+
+    def _print_LatticeOp(self, expr):
+        args = sorted(expr.args, key=default_sort_key)
+        return expr.func.__name__ + "(%s)" % ", ".join(self._print(arg) for arg in args)
+
+    def _print_Limit(self, expr):
+        e, z, z0, dir = expr.args
+        return "Limit(%s, %s, %s, dir='%s')" % tuple(map(self._print, (e, z, z0, dir)))
+
+
+    def _print_list(self, expr):
+        return "[%s]" % self.stringify(expr, ", ")
+
+    def _print_List(self, expr):
+        return self._print_list(expr)
+
+    def _print_MatrixBase(self, expr):
+        return expr._format_str(self)
+
+    def _print_MatrixElement(self, expr):
+        return self.parenthesize(expr.parent, PRECEDENCE["Atom"], strict=True) \
+            + '[%s, %s]' % (self._print(expr.i), self._print(expr.j))
+
+    def _print_MatrixSlice(self, expr):
+        def strslice(x, dim):
+            x = list(x)
+            if x[2] == 1:
+                del x[2]
+            if x[0] == 0:
+                x[0] = ''
+            if x[1] == dim:
+                x[1] = ''
+            return ':'.join((self._print(arg) for arg in x))
+        return (self.parenthesize(expr.parent, PRECEDENCE["Atom"], strict=True) + '[' +
+                strslice(expr.rowslice, expr.parent.rows) + ', ' +
+                strslice(expr.colslice, expr.parent.cols) + ']')
+
+    def _print_DeferredVector(self, expr):
+        return expr.name
+
+    def _print_Mul(self, expr):
+
+        prec = precedence(expr)
+
+        # Check for unevaluated Mul. In this case we need to make sure the
+        # identities are visible, multiple Rational factors are not combined
+        # etc so we display in a straight-forward form that fully preserves all
+        # args and their order.
+        args = expr.args
+        if args[0] is S.One or any(
+                isinstance(a, Number) or
+                a.is_Pow and all(ai.is_Integer for ai in a.args)
+                for a in args[1:]):
+            d, n = sift(args, lambda x:
+                isinstance(x, Pow) and bool(x.exp.as_coeff_Mul()[0] < 0),
+                binary=True)
+            for i, di in enumerate(d):
+                if di.exp.is_Number:
+                    e = -di.exp
+                else:
+                    dargs = list(di.exp.args)
+                    dargs[0] = -dargs[0]
+                    e = Mul._from_args(dargs)
+                d[i] = Pow(di.base, e, evaluate=False) if e - 1 else di.base
+
+            pre = []
+            # don't parenthesize first factor if negative
+            if n and not n[0].is_Add and n[0].could_extract_minus_sign():
+                pre = [self._print(n.pop(0))]
+
+            nfactors = pre + [self.parenthesize(a, prec, strict=False)
+                for a in n]
+            if not nfactors:
+                nfactors = ['1']
+
+            # don't parenthesize first of denominator unless singleton
+            if len(d) > 1 and d[0].could_extract_minus_sign():
+                pre = [self._print(d.pop(0))]
+            else:
+                pre = []
+            dfactors = pre + [self.parenthesize(a, prec, strict=False)
+                for a in d]
+
+            n = '*'.join(nfactors)
+            d = '*'.join(dfactors)
+            if len(dfactors) > 1:
+                return '%s/(%s)' % (n, d)
+            elif dfactors:
+                return '%s/%s' % (n, d)
+            return n
+
+        c, e = expr.as_coeff_Mul()
+        if c < 0:
+            expr = _keep_coeff(-c, e)
+            sign = "-"
+        else:
+            sign = ""
+
+        a = []  # items in the numerator
+        b = []  # items that are in the denominator (if any)
+
+        pow_paren = []  # Will collect all pow with more than one base element and exp = -1
+
+        if self.order not in ('old', 'none'):
+            args = expr.as_ordered_factors()
+        else:
+            # use make_args in case expr was something like -x -> x
+            args = Mul.make_args(expr)
+
+        # Gather args for numerator/denominator
+        def apow(i):
+            b, e = i.as_base_exp()
+            eargs = list(Mul.make_args(e))
+            if eargs[0] is S.NegativeOne:
+                eargs = eargs[1:]
+            else:
+                eargs[0] = -eargs[0]
+            e = Mul._from_args(eargs)
+            if isinstance(i, Pow):
+                return i.func(b, e, evaluate=False)
+            return i.func(e, evaluate=False)
+        for item in args:
+            if (item.is_commutative and
+                    isinstance(item, Pow) and
+                    bool(item.exp.as_coeff_Mul()[0] < 0)):
+                if item.exp is not S.NegativeOne:
+                    b.append(apow(item))
+                else:
+                    if (len(item.args[0].args) != 1 and
+                            isinstance(item.base, (Mul, Pow))):
+                        # To avoid situations like #14160
+                        pow_paren.append(item)
+                    b.append(item.base)
+            elif item.is_Rational and item is not S.Infinity:
+                if item.p != 1:
+                    a.append(Rational(item.p))
+                if item.q != 1:
+                    b.append(Rational(item.q))
+            else:
+                a.append(item)
+
+        a = a or [S.One]
+
+        a_str = [self.parenthesize(x, prec, strict=False) for x in a]
+        b_str = [self.parenthesize(x, prec, strict=False) for x in b]
+
+        # To parenthesize Pow with exp = -1 and having more than one Symbol
+        for item in pow_paren:
+            if item.base in b:
+                b_str[b.index(item.base)] = "(%s)" % b_str[b.index(item.base)]
+
+        if not b:
+            return sign + '*'.join(a_str)
+        elif len(b) == 1:
+            return sign + '*'.join(a_str) + "/" + b_str[0]
+        else:
+            return sign + '*'.join(a_str) + "/(%s)" % '*'.join(b_str)
+
+    def _print_MatMul(self, expr):
+        c, m = expr.as_coeff_mmul()
+
+        sign = ""
+        if c.is_number:
+            re, im = c.as_real_imag()
+            if im.is_zero and re.is_negative:
+                expr = _keep_coeff(-c, m)
+                sign = "-"
+            elif re.is_zero and im.is_negative:
+                expr = _keep_coeff(-c, m)
+                sign = "-"
+
+        return sign + '*'.join(
+            [self.parenthesize(arg, precedence(expr)) for arg in expr.args]
+        )
+
+    def _print_ElementwiseApplyFunction(self, expr):
+        return "{}.({})".format(
+            expr.function,
+            self._print(expr.expr),
+        )
+
+    def _print_NaN(self, expr):
+        return 'nan'
+
+    def _print_NegativeInfinity(self, expr):
+        return '-oo'
+
+    def _print_Order(self, expr):
+        if not expr.variables or all(p is S.Zero for p in expr.point):
+            if len(expr.variables) <= 1:
+                return 'O(%s)' % self._print(expr.expr)
+            else:
+                return 'O(%s)' % self.stringify((expr.expr,) + expr.variables, ', ', 0)
+        else:
+            return 'O(%s)' % self.stringify(expr.args, ', ', 0)
+
+    def _print_Ordinal(self, expr):
+        return expr.__str__()
+
+    def _print_Cycle(self, expr):
+        return expr.__str__()
+
+    def _print_Permutation(self, expr):
+        from sympy.combinatorics.permutations import Permutation, Cycle
+        from sympy.utilities.exceptions import sympy_deprecation_warning
+
+        perm_cyclic = Permutation.print_cyclic
+        if perm_cyclic is not None:
+            sympy_deprecation_warning(
+                f"""
+                Setting Permutation.print_cyclic is deprecated. Instead use
+                init_printing(perm_cyclic={perm_cyclic}).
+                """,
+                deprecated_since_version="1.6",
+                active_deprecations_target="deprecated-permutation-print_cyclic",
+                stacklevel=7,
+            )
+        else:
+            perm_cyclic = self._settings.get("perm_cyclic", True)
+
+        if perm_cyclic:
+            if not expr.size:
+                return '()'
+            # before taking Cycle notation, see if the last element is
+            # a singleton and move it to the head of the string
+            s = Cycle(expr)(expr.size - 1).__repr__()[len('Cycle'):]
+            last = s.rfind('(')
+            if not last == 0 and ',' not in s[last:]:
+                s = s[last:] + s[:last]
+            s = s.replace(',', '')
+            return s
+        else:
+            s = expr.support()
+            if not s:
+                if expr.size < 5:
+                    return 'Permutation(%s)' % self._print(expr.array_form)
+                return 'Permutation([], size=%s)' % self._print(expr.size)
+            trim = self._print(expr.array_form[:s[-1] + 1]) + ', size=%s' % self._print(expr.size)
+            use = full = self._print(expr.array_form)
+            if len(trim) < len(full):
+                use = trim
+            return 'Permutation(%s)' % use
+
+    def _print_Subs(self, obj):
+        expr, old, new = obj.args
+        if len(obj.point) == 1:
+            old = old[0]
+            new = new[0]
+        return "Subs(%s, %s, %s)" % (
+            self._print(expr), self._print(old), self._print(new))
+
+    def _print_TensorIndex(self, expr):
+        return expr._print()
+
+    def _print_TensorHead(self, expr):
+        return expr._print()
+
+    def _print_Tensor(self, expr):
+        return expr._print()
+
+    def _print_TensMul(self, expr):
+        # prints expressions like "A(a)", "3*A(a)", "(1+x)*A(a)"
+        sign, args = expr._get_args_for_traditional_printer()
+        return sign + "*".join(
+            [self.parenthesize(arg, precedence(expr)) for arg in args]
+        )
+
+    def _print_TensAdd(self, expr):
+        return expr._print()
+
+    def _print_ArraySymbol(self, expr):
+        return self._print(expr.name)
+
+    def _print_ArrayElement(self, expr):
+        return "%s[%s]" % (
+            self.parenthesize(expr.name, PRECEDENCE["Func"], True), ", ".join([self._print(i) for i in expr.indices]))
+
+    def _print_PermutationGroup(self, expr):
+        p = ['    %s' % self._print(a) for a in expr.args]
+        return 'PermutationGroup([\n%s])' % ',\n'.join(p)
+
+    def _print_Pi(self, expr):
+        return 'pi'
+
+    def _print_PolyRing(self, ring):
+        return "Polynomial ring in %s over %s with %s order" % \
+            (", ".join((self._print(rs) for rs in ring.symbols)),
+            self._print(ring.domain), self._print(ring.order))
+
+    def _print_FracField(self, field):
+        return "Rational function field in %s over %s with %s order" % \
+            (", ".join((self._print(fs) for fs in field.symbols)),
+            self._print(field.domain), self._print(field.order))
+
+    def _print_FreeGroupElement(self, elm):
+        return elm.__str__()
+
+    def _print_GaussianElement(self, poly):
+        return "(%s + %s*I)" % (poly.x, poly.y)
+
+    def _print_PolyElement(self, poly):
+        return poly.str(self, PRECEDENCE, "%s**%s", "*")
+
+    def _print_FracElement(self, frac):
+        if frac.denom == 1:
+            return self._print(frac.numer)
+        else:
+            numer = self.parenthesize(frac.numer, PRECEDENCE["Mul"], strict=True)
+            denom = self.parenthesize(frac.denom, PRECEDENCE["Atom"], strict=True)
+            return numer + "/" + denom
+
+    def _print_Poly(self, expr):
+        ATOM_PREC = PRECEDENCE["Atom"] - 1
+        terms, gens = [], [ self.parenthesize(s, ATOM_PREC) for s in expr.gens ]
+
+        for monom, coeff in expr.terms():
+            s_monom = []
+
+            for i, e in enumerate(monom):
+                if e > 0:
+                    if e == 1:
+                        s_monom.append(gens[i])
+                    else:
+                        s_monom.append(gens[i] + "**%d" % e)
+
+            s_monom = "*".join(s_monom)
+
+            if coeff.is_Add:
+                if s_monom:
+                    s_coeff = "(" + self._print(coeff) + ")"
+                else:
+                    s_coeff = self._print(coeff)
+            else:
+                if s_monom:
+                    if coeff is S.One:
+                        terms.extend(['+', s_monom])
+                        continue
+
+                    if coeff is S.NegativeOne:
+                        terms.extend(['-', s_monom])
+                        continue
+
+                s_coeff = self._print(coeff)
+
+            if not s_monom:
+                s_term = s_coeff
+            else:
+                s_term = s_coeff + "*" + s_monom
+
+            if s_term.startswith('-'):
+                terms.extend(['-', s_term[1:]])
+            else:
+                terms.extend(['+', s_term])
+
+        if terms[0] in ('-', '+'):
+            modifier = terms.pop(0)
+
+            if modifier == '-':
+                terms[0] = '-' + terms[0]
+
+        format = expr.__class__.__name__ + "(%s, %s"
+
+        from sympy.polys.polyerrors import PolynomialError
+
+        try:
+            format += ", modulus=%s" % expr.get_modulus()
+        except PolynomialError:
+            format += ", domain='%s'" % expr.get_domain()
+
+        format += ")"
+
+        for index, item in enumerate(gens):
+            if len(item) > 2 and (item[:1] == "(" and item[len(item) - 1:] == ")"):
+                gens[index] = item[1:len(item) - 1]
+
+        return format % (' '.join(terms), ', '.join(gens))
+
+    def _print_UniversalSet(self, p):
+        return 'UniversalSet'
+
+    def _print_AlgebraicNumber(self, expr):
+        if expr.is_aliased:
+            return self._print(expr.as_poly().as_expr())
+        else:
+            return self._print(expr.as_expr())
+
+    def _print_Pow(self, expr, rational=False):
+        """Printing helper function for ``Pow``
+
+        Parameters
+        ==========
+
+        rational : bool, optional
+            If ``True``, it will not attempt printing ``sqrt(x)`` or
+            ``x**S.Half`` as ``sqrt``, and will use ``x**(1/2)``
+            instead.
+
+            See examples for additional details
+
+        Examples
+        ========
+
+        >>> from sympy import sqrt, StrPrinter
+        >>> from sympy.abc import x
+
+        How ``rational`` keyword works with ``sqrt``:
+
+        >>> printer = StrPrinter()
+        >>> printer._print_Pow(sqrt(x), rational=True)
+        'x**(1/2)'
+        >>> printer._print_Pow(sqrt(x), rational=False)
+        'sqrt(x)'
+        >>> printer._print_Pow(1/sqrt(x), rational=True)
+        'x**(-1/2)'
+        >>> printer._print_Pow(1/sqrt(x), rational=False)
+        '1/sqrt(x)'
+
+        Notes
+        =====
+
+        ``sqrt(x)`` is canonicalized as ``Pow(x, S.Half)`` in SymPy,
+        so there is no need of defining a separate printer for ``sqrt``.
+        Instead, it should be handled here as well.
+        """
+        PREC = precedence(expr)
+
+        if expr.exp is S.Half and not rational:
+            return "sqrt(%s)" % self._print(expr.base)
+
+        if expr.is_commutative:
+            if -expr.exp is S.Half and not rational:
+                # Note: Don't test "expr.exp == -S.Half" here, because that will
+                # match -0.5, which we don't want.
+                return "%s/sqrt(%s)" % tuple((self._print(arg) for arg in (S.One, expr.base)))
+            if expr.exp is -S.One:
+                # Similarly to the S.Half case, don't test with "==" here.
+                return '%s/%s' % (self._print(S.One),
+                                  self.parenthesize(expr.base, PREC, strict=False))
+
+        e = self.parenthesize(expr.exp, PREC, strict=False)
+        if self.printmethod == '_sympyrepr' and expr.exp.is_Rational and expr.exp.q != 1:
+            # the parenthesized exp should be '(Rational(a, b))' so strip parens,
+            # but just check to be sure.
+            if e.startswith('(Rational'):
+                return '%s**%s' % (self.parenthesize(expr.base, PREC, strict=False), e[1:-1])
+        return '%s**%s' % (self.parenthesize(expr.base, PREC, strict=False), e)
+
+    def _print_UnevaluatedExpr(self, expr):
+        return self._print(expr.args[0])
+
+    def _print_MatPow(self, expr):
+        PREC = precedence(expr)
+        return '%s**%s' % (self.parenthesize(expr.base, PREC, strict=False),
+                         self.parenthesize(expr.exp, PREC, strict=False))
+
+    def _print_Integer(self, expr):
+        if self._settings.get("sympy_integers", False):
+            return "S(%s)" % (expr)
+        return str(expr.p)
+
+    def _print_Integers(self, expr):
+        return 'Integers'
+
+    def _print_Naturals(self, expr):
+        return 'Naturals'
+
+    def _print_Naturals0(self, expr):
+        return 'Naturals0'
+
+    def _print_Rationals(self, expr):
+        return 'Rationals'
+
+    def _print_Reals(self, expr):
+        return 'Reals'
+
+    def _print_Complexes(self, expr):
+        return 'Complexes'
+
+    def _print_EmptySet(self, expr):
+        return 'EmptySet'
+
+    def _print_EmptySequence(self, expr):
+        return 'EmptySequence'
+
+    def _print_int(self, expr):
+        return str(expr)
+
+    def _print_mpz(self, expr):
+        return str(expr)
+
+    def _print_Rational(self, expr):
+        if expr.q == 1:
+            return str(expr.p)
+        else:
+            if self._settings.get("sympy_integers", False):
+                return "S(%s)/%s" % (expr.p, expr.q)
+            return "%s/%s" % (expr.p, expr.q)
+
+    def _print_PythonRational(self, expr):
+        if expr.q == 1:
+            return str(expr.p)
+        else:
+            return "%d/%d" % (expr.p, expr.q)
+
+    def _print_Fraction(self, expr):
+        if expr.denominator == 1:
+            return str(expr.numerator)
+        else:
+            return "%s/%s" % (expr.numerator, expr.denominator)
+
+    def _print_mpq(self, expr):
+        if expr.denominator == 1:
+            return str(expr.numerator)
+        else:
+            return "%s/%s" % (expr.numerator, expr.denominator)
+
+    def _print_Float(self, expr):
+        prec = expr._prec
+        if prec < 5:
+            dps = 0
+        else:
+            dps = prec_to_dps(expr._prec)
+        if self._settings["full_prec"] is True:
+            strip = False
+        elif self._settings["full_prec"] is False:
+            strip = True
+        elif self._settings["full_prec"] == "auto":
+            strip = self._print_level > 1
+        low = self._settings["min"] if "min" in self._settings else None
+        high = self._settings["max"] if "max" in self._settings else None
+        rv = mlib_to_str(expr._mpf_, dps, strip_zeros=strip, min_fixed=low, max_fixed=high)
+        if rv.startswith('-.0'):
+            rv = '-0.' + rv[3:]
+        elif rv.startswith('.0'):
+            rv = '0.' + rv[2:]
+        if rv.startswith('+'):
+            # e.g., +inf -> inf
+            rv = rv[1:]
+        return rv
+
+    def _print_Relational(self, expr):
+
+        charmap = {
+            "==": "Eq",
+            "!=": "Ne",
+            ":=": "Assignment",
+            '+=': "AddAugmentedAssignment",
+            "-=": "SubAugmentedAssignment",
+            "*=": "MulAugmentedAssignment",
+            "/=": "DivAugmentedAssignment",
+            "%=": "ModAugmentedAssignment",
+        }
+
+        if expr.rel_op in charmap:
+            return '%s(%s, %s)' % (charmap[expr.rel_op], self._print(expr.lhs),
+                                   self._print(expr.rhs))
+
+        return '%s %s %s' % (self.parenthesize(expr.lhs, precedence(expr)),
+                           self._relationals.get(expr.rel_op) or expr.rel_op,
+                           self.parenthesize(expr.rhs, precedence(expr)))
+
+    def _print_ComplexRootOf(self, expr):
+        return "CRootOf(%s, %d)" % (self._print_Add(expr.expr,  order='lex'),
+                                    expr.index)
+
+    def _print_RootSum(self, expr):
+        args = [self._print_Add(expr.expr, order='lex')]
+
+        if expr.fun is not S.IdentityFunction:
+            args.append(self._print(expr.fun))
+
+        return "RootSum(%s)" % ", ".join(args)
+
+    def _print_GroebnerBasis(self, basis):
+        cls = basis.__class__.__name__
+
+        exprs = [self._print_Add(arg, order=basis.order) for arg in basis.exprs]
+        exprs = "[%s]" % ", ".join(exprs)
+
+        gens = [ self._print(gen) for gen in basis.gens ]
+        domain = "domain='%s'" % self._print(basis.domain)
+        order = "order='%s'" % self._print(basis.order)
+
+        args = [exprs] + gens + [domain, order]
+
+        return "%s(%s)" % (cls, ", ".join(args))
+
+    def _print_set(self, s):
+        items = sorted(s, key=default_sort_key)
+
+        args = ', '.join(self._print(item) for item in items)
+        if not args:
+            return "set()"
+        return '{%s}' % args
+
+    def _print_FiniteSet(self, s):
+        from sympy.sets.sets import FiniteSet
+        items = sorted(s, key=default_sort_key)
+
+        args = ', '.join(self._print(item) for item in items)
+        if any(item.has(FiniteSet) for item in items):
+            return 'FiniteSet({})'.format(args)
+        return '{{{}}}'.format(args)
+
+    def _print_Partition(self, s):
+        items = sorted(s, key=default_sort_key)
+
+        args = ', '.join(self._print(arg) for arg in items)
+        return 'Partition({})'.format(args)
+
+    def _print_frozenset(self, s):
+        if not s:
+            return "frozenset()"
+        return "frozenset(%s)" % self._print_set(s)
+
+    def _print_Sum(self, expr):
+        def _xab_tostr(xab):
+            if len(xab) == 1:
+                return self._print(xab[0])
+            else:
+                return self._print((xab[0],) + tuple(xab[1:]))
+        L = ', '.join([_xab_tostr(l) for l in expr.limits])
+        return 'Sum(%s, %s)' % (self._print(expr.function), L)
+
+    def _print_Symbol(self, expr):
+        return expr.name
+    _print_MatrixSymbol = _print_Symbol
+    _print_RandomSymbol = _print_Symbol
+
+    def _print_Identity(self, expr):
+        return "I"
+
+    def _print_ZeroMatrix(self, expr):
+        return "0"
+
+    def _print_OneMatrix(self, expr):
+        return "1"
+
+    def _print_Predicate(self, expr):
+        return "Q.%s" % expr.name
+
+    def _print_str(self, expr):
+        return str(expr)
+
+    def _print_tuple(self, expr):
+        if len(expr) == 1:
+            return "(%s,)" % self._print(expr[0])
+        else:
+            return "(%s)" % self.stringify(expr, ", ")
+
+    def _print_Tuple(self, expr):
+        return self._print_tuple(expr)
+
+    def _print_Transpose(self, T):
+        return "%s.T" % self.parenthesize(T.arg, PRECEDENCE["Pow"])
+
+    def _print_Uniform(self, expr):
+        return "Uniform(%s, %s)" % (self._print(expr.a), self._print(expr.b))
+
+    def _print_Quantity(self, expr):
+        if self._settings.get("abbrev", False):
+            return "%s" % expr.abbrev
+        return "%s" % expr.name
+
+    def _print_Quaternion(self, expr):
+        s = [self.parenthesize(i, PRECEDENCE["Mul"], strict=True) for i in expr.args]
+        a = [s[0]] + [i+"*"+j for i, j in zip(s[1:], "ijk")]
+        return " + ".join(a)
+
+    def _print_Dimension(self, expr):
+        return str(expr)
+
+    def _print_Wild(self, expr):
+        return expr.name + '_'
+
+    def _print_WildFunction(self, expr):
+        return expr.name + '_'
+
+    def _print_WildDot(self, expr):
+        return expr.name
+
+    def _print_WildPlus(self, expr):
+        return expr.name
+
+    def _print_WildStar(self, expr):
+        return expr.name
+
+    def _print_Zero(self, expr):
+        if self._settings.get("sympy_integers", False):
+            return "S(0)"
+        return "0"
+
+    def _print_DMP(self, p):
+        try:
+            if p.ring is not None:
+                # TODO incorporate order
+                return self._print(p.ring.to_sympy(p))
+        except SympifyError:
+            pass
+
+        cls = p.__class__.__name__
+        rep = self._print(p.rep)
+        dom = self._print(p.dom)
+        ring = self._print(p.ring)
+
+        return "%s(%s, %s, %s)" % (cls, rep, dom, ring)
+
+    def _print_DMF(self, expr):
+        return self._print_DMP(expr)
+
+    def _print_Object(self, obj):
+        return 'Object("%s")' % obj.name
+
+    def _print_IdentityMorphism(self, morphism):
+        return 'IdentityMorphism(%s)' % morphism.domain
+
+    def _print_NamedMorphism(self, morphism):
+        return 'NamedMorphism(%s, %s, "%s")' % \
+               (morphism.domain, morphism.codomain, morphism.name)
+
+    def _print_Category(self, category):
+        return 'Category("%s")' % category.name
+
+    def _print_Manifold(self, manifold):
+        return manifold.name.name
+
+    def _print_Patch(self, patch):
+        return patch.name.name
+
+    def _print_CoordSystem(self, coords):
+        return coords.name.name
+
+    def _print_BaseScalarField(self, field):
+        return field._coord_sys.symbols[field._index].name
+
+    def _print_BaseVectorField(self, field):
+        return 'e_%s' % field._coord_sys.symbols[field._index].name
+
+    def _print_Differential(self, diff):
+        field = diff._form_field
+        if hasattr(field, '_coord_sys'):
+            return 'd%s' % field._coord_sys.symbols[field._index].name
+        else:
+            return 'd(%s)' % self._print(field)
+
+    def _print_Tr(self, expr):
+        #TODO : Handle indices
+        return "%s(%s)" % ("Tr", self._print(expr.args[0]))
+
+    def _print_Str(self, s):
+        return self._print(s.name)
+
+    def _print_AppliedBinaryRelation(self, expr):
+        rel = expr.function
+        return '%s(%s, %s)' % (self._print(rel),
+                               self._print(expr.lhs),
+                               self._print(expr.rhs))
+
+
+@print_function(StrPrinter)
+def sstr(expr, **settings):
+    """Returns the expression as a string.
+
+    For large expressions where speed is a concern, use the setting
+    order='none'. If abbrev=True setting is used then units are printed in
+    abbreviated form.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Eq, sstr
+    >>> a, b = symbols('a b')
+    >>> sstr(Eq(a + b, 0))
+    'Eq(a + b, 0)'
+    """
+
+    p = StrPrinter(settings)
+    s = p.doprint(expr)
+
+    return s
+
+
+class StrReprPrinter(StrPrinter):
+    """(internal) -- see sstrrepr"""
+
+    def _print_str(self, s):
+        return repr(s)
+
+    def _print_Str(self, s):
+        # Str does not to be printed same as str here
+        return "%s(%s)" % (s.__class__.__name__, self._print(s.name))
+
+
+@print_function(StrReprPrinter)
+def sstrrepr(expr, **settings):
+    """return expr in mixed str/repr form
+
+       i.e. strings are returned in repr form with quotes, and everything else
+       is returned in str form.
+
+       This function could be useful for hooking into sys.displayhook
+    """
+
+    p = StrReprPrinter(settings)
+    s = p.doprint(expr)
+
+    return s

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_aesaracode.py

@@ -0,0 +1,626 @@
+"""
+Important note on tests in this module - the Aesara printing functions use a
+global cache by default, which means that tests using it will modify global
+state and thus not be independent from each other. Instead of using the "cache"
+keyword argument each time, this module uses the aesara_code_ and
+aesara_function_ functions defined below which default to using a new, empty
+cache instead.
+"""
+
+import logging
+
+from sympy.external import import_module
+from sympy.testing.pytest import raises, SKIP
+
+from sympy.utilities.exceptions import ignore_warnings
+
+
+aesaralogger = logging.getLogger('aesara.configdefaults')
+aesaralogger.setLevel(logging.CRITICAL)
+aesara = import_module('aesara')
+aesaralogger.setLevel(logging.WARNING)
+
+
+if aesara:
+    import numpy as np
+    aet = aesara.tensor
+    from aesara.scalar.basic import Scalar
+    from aesara.graph.basic import Variable
+    from aesara.tensor.var import TensorVariable
+    from aesara.tensor.elemwise import Elemwise, DimShuffle
+    from aesara.tensor.math import Dot
+
+    from sympy.printing.aesaracode import true_divide
+
+    xt, yt, zt = [aet.scalar(name, 'floatX') for name in 'xyz']
+    Xt, Yt, Zt = [aet.tensor('floatX', (False, False), name=n) for n in 'XYZ']
+else:
+    #bin/test will not execute any tests now
+    disabled = True
+
+import sympy as sy
+from sympy.core.singleton import S
+from sympy.abc import x, y, z, t
+from sympy.printing.aesaracode import (aesara_code, dim_handling,
+        aesara_function)
+
+
+# Default set of matrix symbols for testing - make square so we can both
+# multiply and perform elementwise operations between them.
+X, Y, Z = [sy.MatrixSymbol(n, 4, 4) for n in 'XYZ']
+
+# For testing AppliedUndef
+f_t = sy.Function('f')(t)
+
+
+def aesara_code_(expr, **kwargs):
+    """ Wrapper for aesara_code that uses a new, empty cache by default. """
+    kwargs.setdefault('cache', {})
+    return aesara_code(expr, **kwargs)
+
+def aesara_function_(inputs, outputs, **kwargs):
+    """ Wrapper for aesara_function that uses a new, empty cache by default. """
+    kwargs.setdefault('cache', {})
+    return aesara_function(inputs, outputs, **kwargs)
+
+
+def fgraph_of(*exprs):
+    """ Transform SymPy expressions into Aesara Computation.
+
+    Parameters
+    ==========
+    exprs
+        SymPy expressions
+
+    Returns
+    =======
+    aesara.graph.fg.FunctionGraph
+    """
+    outs = list(map(aesara_code_, exprs))
+    ins = list(aesara.graph.basic.graph_inputs(outs))
+    ins, outs = aesara.graph.basic.clone(ins, outs)
+    return aesara.graph.fg.FunctionGraph(ins, outs)
+
+
+def aesara_simplify(fgraph):
+    """ Simplify a Aesara Computation.
+
+    Parameters
+    ==========
+    fgraph : aesara.graph.fg.FunctionGraph
+
+    Returns
+    =======
+    aesara.graph.fg.FunctionGraph
+    """
+    mode = aesara.compile.get_default_mode().excluding("fusion")
+    fgraph = fgraph.clone()
+    mode.optimizer.optimize(fgraph)
+    return fgraph
+
+
+def theq(a, b):
+    """ Test two Aesara objects for equality.
+
+    Also accepts numeric types and lists/tuples of supported types.
+
+    Note - debugprint() has a bug where it will accept numeric types but does
+    not respect the "file" argument and in this case and instead prints the number
+    to stdout and returns an empty string. This can lead to tests passing where
+    they should fail because any two numbers will always compare as equal. To
+    prevent this we treat numbers as a separate case.
+    """
+    numeric_types = (int, float, np.number)
+    a_is_num = isinstance(a, numeric_types)
+    b_is_num = isinstance(b, numeric_types)
+
+    # Compare numeric types using regular equality
+    if a_is_num or b_is_num:
+        if not (a_is_num and b_is_num):
+            return False
+
+        return a == b
+
+    # Compare sequences element-wise
+    a_is_seq = isinstance(a, (tuple, list))
+    b_is_seq = isinstance(b, (tuple, list))
+
+    if a_is_seq or b_is_seq:
+        if not (a_is_seq and b_is_seq) or type(a) != type(b):
+            return False
+
+        return list(map(theq, a)) == list(map(theq, b))
+
+    # Otherwise, assume debugprint() can handle it
+    astr = aesara.printing.debugprint(a, file='str')
+    bstr = aesara.printing.debugprint(b, file='str')
+
+    # Check for bug mentioned above
+    for argname, argval, argstr in [('a', a, astr), ('b', b, bstr)]:
+        if argstr == '':
+            raise TypeError(
+                'aesara.printing.debugprint(%s) returned empty string '
+                '(%s is instance of %r)'
+                % (argname, argname, type(argval))
+            )
+
+    return astr == bstr
+
+
+def test_example_symbols():
+    """
+    Check that the example symbols in this module print to their Aesara
+    equivalents, as many of the other tests depend on this.
+    """
+    assert theq(xt, aesara_code_(x))
+    assert theq(yt, aesara_code_(y))
+    assert theq(zt, aesara_code_(z))
+    assert theq(Xt, aesara_code_(X))
+    assert theq(Yt, aesara_code_(Y))
+    assert theq(Zt, aesara_code_(Z))
+
+
+def test_Symbol():
+    """ Test printing a Symbol to a aesara variable. """
+    xx = aesara_code_(x)
+    assert isinstance(xx, Variable)
+    assert xx.broadcastable == ()
+    assert xx.name == x.name
+
+    xx2 = aesara_code_(x, broadcastables={x: (False,)})
+    assert xx2.broadcastable == (False,)
+    assert xx2.name == x.name
+
+def test_MatrixSymbol():
+    """ Test printing a MatrixSymbol to a aesara variable. """
+    XX = aesara_code_(X)
+    assert isinstance(XX, TensorVariable)
+    assert XX.broadcastable == (False, False)
+
+@SKIP  # TODO - this is currently not checked but should be implemented
+def test_MatrixSymbol_wrong_dims():
+    """ Test MatrixSymbol with invalid broadcastable. """
+    bcs = [(), (False,), (True,), (True, False), (False, True,), (True, True)]
+    for bc in bcs:
+        with raises(ValueError):
+            aesara_code_(X, broadcastables={X: bc})
+
+def test_AppliedUndef():
+    """ Test printing AppliedUndef instance, which works similarly to Symbol. """
+    ftt = aesara_code_(f_t)
+    assert isinstance(ftt, TensorVariable)
+    assert ftt.broadcastable == ()
+    assert ftt.name == 'f_t'
+
+
+def test_add():
+    expr = x + y
+    comp = aesara_code_(expr)
+    assert comp.owner.op == aesara.tensor.add
+
+def test_trig():
+    assert theq(aesara_code_(sy.sin(x)), aet.sin(xt))
+    assert theq(aesara_code_(sy.tan(x)), aet.tan(xt))
+
+def test_many():
+    """ Test printing a complex expression with multiple symbols. """
+    expr = sy.exp(x**2 + sy.cos(y)) * sy.log(2*z)
+    comp = aesara_code_(expr)
+    expected = aet.exp(xt**2 + aet.cos(yt)) * aet.log(2*zt)
+    assert theq(comp, expected)
+
+
+def test_dtype():
+    """ Test specifying specific data types through the dtype argument. """
+    for dtype in ['float32', 'float64', 'int8', 'int16', 'int32', 'int64']:
+        assert aesara_code_(x, dtypes={x: dtype}).type.dtype == dtype
+
+    # "floatX" type
+    assert aesara_code_(x, dtypes={x: 'floatX'}).type.dtype in ('float32', 'float64')
+
+    # Type promotion
+    assert aesara_code_(x + 1, dtypes={x: 'float32'}).type.dtype == 'float32'
+    assert aesara_code_(x + y, dtypes={x: 'float64', y: 'float32'}).type.dtype == 'float64'
+
+
+def test_broadcastables():
+    """ Test the "broadcastables" argument when printing symbol-like objects. """
+
+    # No restrictions on shape
+    for s in [x, f_t]:
+        for bc in [(), (False,), (True,), (False, False), (True, False)]:
+            assert aesara_code_(s, broadcastables={s: bc}).broadcastable == bc
+
+    # TODO - matrix broadcasting?
+
+def test_broadcasting():
+    """ Test "broadcastable" attribute after applying element-wise binary op. """
+
+    expr = x + y
+
+    cases = [
+        [(), (), ()],
+        [(False,), (False,), (False,)],
+        [(True,), (False,), (False,)],
+        [(False, True), (False, False), (False, False)],
+        [(True, False), (False, False), (False, False)],
+    ]
+
+    for bc1, bc2, bc3 in cases:
+        comp = aesara_code_(expr, broadcastables={x: bc1, y: bc2})
+        assert comp.broadcastable == bc3
+
+
+def test_MatMul():
+    expr = X*Y*Z
+    expr_t = aesara_code_(expr)
+    assert isinstance(expr_t.owner.op, Dot)
+    assert theq(expr_t, Xt.dot(Yt).dot(Zt))
+
+def test_Transpose():
+    assert isinstance(aesara_code_(X.T).owner.op, DimShuffle)
+
+def test_MatAdd():
+    expr = X+Y+Z
+    assert isinstance(aesara_code_(expr).owner.op, Elemwise)
+
+
+def test_Rationals():
+    assert theq(aesara_code_(sy.Integer(2) / 3), true_divide(2, 3))
+    assert theq(aesara_code_(S.Half), true_divide(1, 2))
+
+def test_Integers():
+    assert aesara_code_(sy.Integer(3)) == 3
+
+def test_factorial():
+    n = sy.Symbol('n')
+    assert aesara_code_(sy.factorial(n))
+
+def test_Derivative():
+    with ignore_warnings(UserWarning):
+        simp = lambda expr: aesara_simplify(fgraph_of(expr))
+        assert theq(simp(aesara_code_(sy.Derivative(sy.sin(x), x, evaluate=False))),
+                    simp(aesara.grad(aet.sin(xt), xt)))
+
+
+def test_aesara_function_simple():
+    """ Test aesara_function() with single output. """
+    f = aesara_function_([x, y], [x+y])
+    assert f(2, 3) == 5
+
+def test_aesara_function_multi():
+    """ Test aesara_function() with multiple outputs. """
+    f = aesara_function_([x, y], [x+y, x-y])
+    o1, o2 = f(2, 3)
+    assert o1 == 5
+    assert o2 == -1
+
+def test_aesara_function_numpy():
+    """ Test aesara_function() vs Numpy implementation. """
+    f = aesara_function_([x, y], [x+y], dim=1,
+                         dtypes={x: 'float64', y: 'float64'})
+    assert np.linalg.norm(f([1, 2], [3, 4]) - np.asarray([4, 6])) < 1e-9
+
+    f = aesara_function_([x, y], [x+y], dtypes={x: 'float64', y: 'float64'},
+                         dim=1)
+    xx = np.arange(3).astype('float64')
+    yy = 2*np.arange(3).astype('float64')
+    assert np.linalg.norm(f(xx, yy) - 3*np.arange(3)) < 1e-9
+
+
+def test_aesara_function_matrix():
+    m = sy.Matrix([[x, y], [z, x + y + z]])
+    expected = np.array([[1.0, 2.0], [3.0, 1.0 + 2.0 + 3.0]])
+    f = aesara_function_([x, y, z], [m])
+    np.testing.assert_allclose(f(1.0, 2.0, 3.0), expected)
+    f = aesara_function_([x, y, z], [m], scalar=True)
+    np.testing.assert_allclose(f(1.0, 2.0, 3.0), expected)
+    f = aesara_function_([x, y, z], [m, m])
+    assert isinstance(f(1.0, 2.0, 3.0), type([]))
+    np.testing.assert_allclose(f(1.0, 2.0, 3.0)[0], expected)
+    np.testing.assert_allclose(f(1.0, 2.0, 3.0)[1], expected)
+
+def test_dim_handling():
+    assert dim_handling([x], dim=2) == {x: (False, False)}
+    assert dim_handling([x, y], dims={x: 1, y: 2}) == {x: (False, True),
+                                                       y: (False, False)}
+    assert dim_handling([x], broadcastables={x: (False,)}) == {x: (False,)}
+
+def test_aesara_function_kwargs():
+    """
+    Test passing additional kwargs from aesara_function() to aesara.function().
+    """
+    import numpy as np
+    f = aesara_function_([x, y, z], [x+y], dim=1, on_unused_input='ignore',
+            dtypes={x: 'float64', y: 'float64', z: 'float64'})
+    assert np.linalg.norm(f([1, 2], [3, 4], [0, 0]) - np.asarray([4, 6])) < 1e-9
+
+    f = aesara_function_([x, y, z], [x+y],
+                        dtypes={x: 'float64', y: 'float64', z: 'float64'},
+                        dim=1, on_unused_input='ignore')
+    xx = np.arange(3).astype('float64')
+    yy = 2*np.arange(3).astype('float64')
+    zz = 2*np.arange(3).astype('float64')
+    assert np.linalg.norm(f(xx, yy, zz) - 3*np.arange(3)) < 1e-9
+
+def test_aesara_function_scalar():
+    """ Test the "scalar" argument to aesara_function(). """
+    from aesara.compile.function.types import Function
+
+    args = [
+        ([x, y], [x + y], None, [0]),  # Single 0d output
+        ([X, Y], [X + Y], None, [2]),  # Single 2d output
+        ([x, y], [x + y], {x: 0, y: 1}, [1]),  # Single 1d output
+        ([x, y], [x + y, x - y], None, [0, 0]),  # Two 0d outputs
+        ([x, y, X, Y], [x + y, X + Y], None, [0, 2]),  # One 0d output, one 2d
+    ]
+
+    # Create and test functions with and without the scalar setting
+    for inputs, outputs, in_dims, out_dims in args:
+        for scalar in [False, True]:
+
+            f = aesara_function_(inputs, outputs, dims=in_dims, scalar=scalar)
+
+            # Check the aesara_function attribute is set whether wrapped or not
+            assert isinstance(f.aesara_function, Function)
+
+            # Feed in inputs of the appropriate size and get outputs
+            in_values = [
+                np.ones([1 if bc else 5 for bc in i.type.broadcastable])
+                for i in f.aesara_function.input_storage
+            ]
+            out_values = f(*in_values)
+            if not isinstance(out_values, list):
+                out_values = [out_values]
+
+            # Check output types and shapes
+            assert len(out_dims) == len(out_values)
+            for d, value in zip(out_dims, out_values):
+
+                if scalar and d == 0:
+                    # Should have been converted to a scalar value
+                    assert isinstance(value, np.number)
+
+                else:
+                    # Otherwise should be an array
+                    assert isinstance(value, np.ndarray)
+                    assert value.ndim == d
+
+def test_aesara_function_bad_kwarg():
+    """
+    Passing an unknown keyword argument to aesara_function() should raise an
+    exception.
+    """
+    raises(Exception, lambda : aesara_function_([x], [x+1], foobar=3))
+
+
+def test_slice():
+    assert aesara_code_(slice(1, 2, 3)) == slice(1, 2, 3)
+
+    def theq_slice(s1, s2):
+        for attr in ['start', 'stop', 'step']:
+            a1 = getattr(s1, attr)
+            a2 = getattr(s2, attr)
+            if a1 is None or a2 is None:
+                if not (a1 is None or a2 is None):
+                    return False
+            elif not theq(a1, a2):
+                return False
+        return True
+
+    dtypes = {x: 'int32', y: 'int32'}
+    assert theq_slice(aesara_code_(slice(x, y), dtypes=dtypes), slice(xt, yt))
+    assert theq_slice(aesara_code_(slice(1, x, 3), dtypes=dtypes), slice(1, xt, 3))
+
+def test_MatrixSlice():
+    cache = {}
+
+    n = sy.Symbol('n', integer=True)
+    X = sy.MatrixSymbol('X', n, n)
+
+    Y = X[1:2:3, 4:5:6]
+    Yt = aesara_code_(Y, cache=cache)
+
+    s = Scalar('int64')
+    assert tuple(Yt.owner.op.idx_list) == (slice(s, s, s), slice(s, s, s))
+    assert Yt.owner.inputs[0] == aesara_code_(X, cache=cache)
+    # == doesn't work in Aesara like it does in SymPy. You have to use
+    # equals.
+    assert all(Yt.owner.inputs[i].data == i for i in range(1, 7))
+
+    k = sy.Symbol('k')
+    aesara_code_(k, dtypes={k: 'int32'})
+    start, stop, step = 4, k, 2
+    Y = X[start:stop:step]
+    Yt = aesara_code_(Y, dtypes={n: 'int32', k: 'int32'})
+    # assert Yt.owner.op.idx_list[0].stop == kt
+
+def test_BlockMatrix():
+    n = sy.Symbol('n', integer=True)
+    A, B, C, D = [sy.MatrixSymbol(name, n, n) for name in 'ABCD']
+    At, Bt, Ct, Dt = map(aesara_code_, (A, B, C, D))
+    Block = sy.BlockMatrix([[A, B], [C, D]])
+    Blockt = aesara_code_(Block)
+    solutions = [aet.join(0, aet.join(1, At, Bt), aet.join(1, Ct, Dt)),
+                 aet.join(1, aet.join(0, At, Ct), aet.join(0, Bt, Dt))]
+    assert any(theq(Blockt, solution) for solution in solutions)
+
+@SKIP
+def test_BlockMatrix_Inverse_execution():
+    k, n = 2, 4
+    dtype = 'float32'
+    A = sy.MatrixSymbol('A', n, k)
+    B = sy.MatrixSymbol('B', n, n)
+    inputs = A, B
+    output = B.I*A
+
+    cutsizes = {A: [(n//2, n//2), (k//2, k//2)],
+                B: [(n//2, n//2), (n//2, n//2)]}
+    cutinputs = [sy.blockcut(i, *cutsizes[i]) for i in inputs]
+    cutoutput = output.subs(dict(zip(inputs, cutinputs)))
+
+    dtypes = dict(zip(inputs, [dtype]*len(inputs)))
+    f = aesara_function_(inputs, [output], dtypes=dtypes, cache={})
+    fblocked = aesara_function_(inputs, [sy.block_collapse(cutoutput)],
+                                dtypes=dtypes, cache={})
+
+    ninputs = [np.random.rand(*x.shape).astype(dtype) for x in inputs]
+    ninputs = [np.arange(n*k).reshape(A.shape).astype(dtype),
+               np.eye(n).astype(dtype)]
+    ninputs[1] += np.ones(B.shape)*1e-5
+
+    assert np.allclose(f(*ninputs), fblocked(*ninputs), rtol=1e-5)
+
+def test_DenseMatrix():
+    from aesara.tensor.basic import Join
+
+    t = sy.Symbol('theta')
+    for MatrixType in [sy.Matrix, sy.ImmutableMatrix]:
+        X = MatrixType([[sy.cos(t), -sy.sin(t)], [sy.sin(t), sy.cos(t)]])
+        tX = aesara_code_(X)
+        assert isinstance(tX, TensorVariable)
+        assert isinstance(tX.owner.op, Join)
+
+
+def test_cache_basic():
+    """ Test single symbol-like objects are cached when printed by themselves. """
+
+    # Pairs of objects which should be considered equivalent with respect to caching
+    pairs = [
+        (x, sy.Symbol('x')),
+        (X, sy.MatrixSymbol('X', *X.shape)),
+        (f_t, sy.Function('f')(sy.Symbol('t'))),
+    ]
+
+    for s1, s2 in pairs:
+        cache = {}
+        st = aesara_code_(s1, cache=cache)
+
+        # Test hit with same instance
+        assert aesara_code_(s1, cache=cache) is st
+
+        # Test miss with same instance but new cache
+        assert aesara_code_(s1, cache={}) is not st
+
+        # Test hit with different but equivalent instance
+        assert aesara_code_(s2, cache=cache) is st
+
+def test_global_cache():
+    """ Test use of the global cache. """
+    from sympy.printing.aesaracode import global_cache
+
+    backup = dict(global_cache)
+    try:
+        # Temporarily empty global cache
+        global_cache.clear()
+
+        for s in [x, X, f_t]:
+            st = aesara_code(s)
+            assert aesara_code(s) is st
+
+    finally:
+        # Restore global cache
+        global_cache.update(backup)
+
+def test_cache_types_distinct():
+    """
+    Test that symbol-like objects of different types (Symbol, MatrixSymbol,
+    AppliedUndef) are distinguished by the cache even if they have the same
+    name.
+    """
+    symbols = [sy.Symbol('f_t'), sy.MatrixSymbol('f_t', 4, 4), f_t]
+
+    cache = {}  # Single shared cache
+    printed = {}
+
+    for s in symbols:
+        st = aesara_code_(s, cache=cache)
+        assert st not in printed.values()
+        printed[s] = st
+
+    # Check all printed objects are distinct
+    assert len(set(map(id, printed.values()))) == len(symbols)
+
+    # Check retrieving
+    for s, st in printed.items():
+        assert aesara_code(s, cache=cache) is st
+
+def test_symbols_are_created_once():
+    """
+    Test that a symbol is cached and reused when it appears in an expression
+    more than once.
+    """
+    expr = sy.Add(x, x, evaluate=False)
+    comp = aesara_code_(expr)
+
+    assert theq(comp, xt + xt)
+    assert not theq(comp, xt + aesara_code_(x))
+
+def test_cache_complex():
+    """
+    Test caching on a complicated expression with multiple symbols appearing
+    multiple times.
+    """
+    expr = x ** 2 + (y - sy.exp(x)) * sy.sin(z - x * y)
+    symbol_names = {s.name for s in expr.free_symbols}
+    expr_t = aesara_code_(expr)
+
+    # Iterate through variables in the Aesara computational graph that the
+    # printed expression depends on
+    seen = set()
+    for v in aesara.graph.basic.ancestors([expr_t]):
+        # Owner-less, non-constant variables should be our symbols
+        if v.owner is None and not isinstance(v, aesara.graph.basic.Constant):
+            # Check it corresponds to a symbol and appears only once
+            assert v.name in symbol_names
+            assert v.name not in seen
+            seen.add(v.name)
+
+    # Check all were present
+    assert seen == symbol_names
+
+
+def test_Piecewise():
+    # A piecewise linear
+    expr = sy.Piecewise((0, x<0), (x, x<2), (1, True))  # ___/III
+    result = aesara_code_(expr)
+    assert result.owner.op == aet.switch
+
+    expected = aet.switch(xt<0, 0, aet.switch(xt<2, xt, 1))
+    assert theq(result, expected)
+
+    expr = sy.Piecewise((x, x < 0))
+    result = aesara_code_(expr)
+    expected = aet.switch(xt < 0, xt, np.nan)
+    assert theq(result, expected)
+
+    expr = sy.Piecewise((0, sy.And(x>0, x<2)), \
+        (x, sy.Or(x>2, x<0)))
+    result = aesara_code_(expr)
+    expected = aet.switch(aet.and_(xt>0,xt<2), 0, \
+        aet.switch(aet.or_(xt>2, xt<0), xt, np.nan))
+    assert theq(result, expected)
+
+
+def test_Relationals():
+    assert theq(aesara_code_(sy.Eq(x, y)), aet.eq(xt, yt))
+    # assert theq(aesara_code_(sy.Ne(x, y)), aet.neq(xt, yt))  # TODO - implement
+    assert theq(aesara_code_(x > y), xt > yt)
+    assert theq(aesara_code_(x < y), xt < yt)
+    assert theq(aesara_code_(x >= y), xt >= yt)
+    assert theq(aesara_code_(x <= y), xt <= yt)
+
+
+def test_complexfunctions():
+    dtypes = {x:'complex128', y:'complex128'}
+    xt, yt = aesara_code(x, dtypes=dtypes), aesara_code(y, dtypes=dtypes)
+    from sympy.functions.elementary.complexes import conjugate
+    from aesara.tensor import as_tensor_variable as atv
+    from aesara.tensor import complex as cplx
+    assert theq(aesara_code(y*conjugate(x), dtypes=dtypes), yt*(xt.conj()))
+    assert theq(aesara_code((1+2j)*x), xt*(atv(1.0)+atv(2.0)*cplx(0,1)))
+
+
+def test_constantfunctions():
+    tf = aesara_function([],[1+1j])
+    assert(tf()==1+1j)

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_c.py

@@ -0,0 +1,875 @@
+from sympy.core import (
+    S, pi, oo, Symbol, symbols, Rational, Integer, Float, Function, Mod, GoldenRatio, EulerGamma, Catalan,
+    Lambda, Dummy, nan, Mul, Pow, UnevaluatedExpr
+)
+from sympy.core.relational import (Eq, Ge, Gt, Le, Lt, Ne)
+from sympy.functions import (
+    Abs, acos, acosh, asin, asinh, atan, atanh, atan2, ceiling, cos, cosh, erf,
+    erfc, exp, floor, gamma, log, loggamma, Max, Min, Piecewise, sign, sin, sinh,
+    sqrt, tan, tanh, fibonacci, lucas
+)
+from sympy.sets import Range
+from sympy.logic import ITE, Implies, Equivalent
+from sympy.codegen import For, aug_assign, Assignment
+from sympy.testing.pytest import raises, XFAIL
+from sympy.printing.c import C89CodePrinter, C99CodePrinter, get_math_macros
+from sympy.codegen.ast import (
+    AddAugmentedAssignment, Element, Type, FloatType, Declaration, Pointer, Variable, value_const, pointer_const,
+    While, Scope, Print, FunctionPrototype, FunctionDefinition, FunctionCall, Return,
+    real, float32, float64, float80, float128, intc, Comment, CodeBlock
+)
+from sympy.codegen.cfunctions import expm1, log1p, exp2, log2, fma, log10, Cbrt, hypot, Sqrt
+from sympy.codegen.cnodes import restrict
+from sympy.utilities.lambdify import implemented_function
+from sympy.tensor import IndexedBase, Idx
+from sympy.matrices import Matrix, MatrixSymbol, SparseMatrix
+
+from sympy.printing.codeprinter import ccode
+
+x, y, z = symbols('x,y,z')
+
+
+def test_printmethod():
+    class fabs(Abs):
+        def _ccode(self, printer):
+            return "fabs(%s)" % printer._print(self.args[0])
+
+    assert ccode(fabs(x)) == "fabs(x)"
+
+
+def test_ccode_sqrt():
+    assert ccode(sqrt(x)) == "sqrt(x)"
+    assert ccode(x**0.5) == "sqrt(x)"
+    assert ccode(sqrt(x)) == "sqrt(x)"
+
+
+def test_ccode_Pow():
+    assert ccode(x**3) == "pow(x, 3)"
+    assert ccode(x**(y**3)) == "pow(x, pow(y, 3))"
+    g = implemented_function('g', Lambda(x, 2*x))
+    assert ccode(1/(g(x)*3.5)**(x - y**x)/(x**2 + y)) == \
+        "pow(3.5*2*x, -x + pow(y, x))/(pow(x, 2) + y)"
+    assert ccode(x**-1.0) == '1.0/x'
+    assert ccode(x**Rational(2, 3)) == 'pow(x, 2.0/3.0)'
+    assert ccode(x**Rational(2, 3), type_aliases={real: float80}) == 'powl(x, 2.0L/3.0L)'
+    _cond_cfunc = [(lambda base, exp: exp.is_integer, "dpowi"),
+                   (lambda base, exp: not exp.is_integer, "pow")]
+    assert ccode(x**3, user_functions={'Pow': _cond_cfunc}) == 'dpowi(x, 3)'
+    assert ccode(x**0.5, user_functions={'Pow': _cond_cfunc}) == 'pow(x, 0.5)'
+    assert ccode(x**Rational(16, 5), user_functions={'Pow': _cond_cfunc}) == 'pow(x, 16.0/5.0)'
+    _cond_cfunc2 = [(lambda base, exp: base == 2, lambda base, exp: 'exp2(%s)' % exp),
+                    (lambda base, exp: base != 2, 'pow')]
+    # Related to gh-11353
+    assert ccode(2**x, user_functions={'Pow': _cond_cfunc2}) == 'exp2(x)'
+    assert ccode(x**2, user_functions={'Pow': _cond_cfunc2}) == 'pow(x, 2)'
+    # For issue 14160
+    assert ccode(Mul(-2, x, Pow(Mul(y,y,evaluate=False), -1, evaluate=False),
+                                                evaluate=False)) == '-2*x/(y*y)'
+
+
+def test_ccode_Max():
+    # Test for gh-11926
+    assert ccode(Max(x,x*x),user_functions={"Max":"my_max", "Pow":"my_pow"}) == 'my_max(x, my_pow(x, 2))'
+
+
+def test_ccode_Min_performance():
+    #Shouldn't take more than a few seconds
+    big_min = Min(*symbols('a[0:50]'))
+    for curr_standard in ('c89', 'c99', 'c11'):
+        output = ccode(big_min, standard=curr_standard)
+        assert output.count('(') == output.count(')')
+
+
+def test_ccode_constants_mathh():
+    assert ccode(exp(1)) == "M_E"
+    assert ccode(pi) == "M_PI"
+    assert ccode(oo, standard='c89') == "HUGE_VAL"
+    assert ccode(-oo, standard='c89') == "-HUGE_VAL"
+    assert ccode(oo) == "INFINITY"
+    assert ccode(-oo, standard='c99') == "-INFINITY"
+    assert ccode(pi, type_aliases={real: float80}) == "M_PIl"
+
+
+def test_ccode_constants_other():
+    assert ccode(2*GoldenRatio) == "const double GoldenRatio = %s;\n2*GoldenRatio" % GoldenRatio.evalf(17)
+    assert ccode(
+        2*Catalan) == "const double Catalan = %s;\n2*Catalan" % Catalan.evalf(17)
+    assert ccode(2*EulerGamma) == "const double EulerGamma = %s;\n2*EulerGamma" % EulerGamma.evalf(17)
+
+
+def test_ccode_Rational():
+    assert ccode(Rational(3, 7)) == "3.0/7.0"
+    assert ccode(Rational(3, 7), type_aliases={real: float80}) == "3.0L/7.0L"
+    assert ccode(Rational(18, 9)) == "2"
+    assert ccode(Rational(3, -7)) == "-3.0/7.0"
+    assert ccode(Rational(3, -7), type_aliases={real: float80}) == "-3.0L/7.0L"
+    assert ccode(Rational(-3, -7)) == "3.0/7.0"
+    assert ccode(Rational(-3, -7), type_aliases={real: float80}) == "3.0L/7.0L"
+    assert ccode(x + Rational(3, 7)) == "x + 3.0/7.0"
+    assert ccode(x + Rational(3, 7), type_aliases={real: float80}) == "x + 3.0L/7.0L"
+    assert ccode(Rational(3, 7)*x) == "(3.0/7.0)*x"
+    assert ccode(Rational(3, 7)*x, type_aliases={real: float80}) == "(3.0L/7.0L)*x"
+
+
+def test_ccode_Integer():
+    assert ccode(Integer(67)) == "67"
+    assert ccode(Integer(-1)) == "-1"
+
+
+def test_ccode_functions():
+    assert ccode(sin(x) ** cos(x)) == "pow(sin(x), cos(x))"
+
+
+def test_ccode_inline_function():
+    x = symbols('x')
+    g = implemented_function('g', Lambda(x, 2*x))
+    assert ccode(g(x)) == "2*x"
+    g = implemented_function('g', Lambda(x, 2*x/Catalan))
+    assert ccode(
+        g(x)) == "const double Catalan = %s;\n2*x/Catalan" % Catalan.evalf(17)
+    A = IndexedBase('A')
+    i = Idx('i', symbols('n', integer=True))
+    g = implemented_function('g', Lambda(x, x*(1 + x)*(2 + x)))
+    assert ccode(g(A[i]), assign_to=A[i]) == (
+        "for (int i=0; i<n; i++){\n"
+        "   A[i] = (A[i] + 1)*(A[i] + 2)*A[i];\n"
+        "}"
+    )
+
+
+def test_ccode_exceptions():
+    assert ccode(gamma(x), standard='C99') == "tgamma(x)"
+    gamma_c89 = ccode(gamma(x), standard='C89')
+    assert 'not supported in c' in gamma_c89.lower()
+    gamma_c89 = ccode(gamma(x), standard='C89', allow_unknown_functions=False)
+    assert 'not supported in c' in gamma_c89.lower()
+    gamma_c89 = ccode(gamma(x), standard='C89', allow_unknown_functions=True)
+    assert 'not supported in c' not in gamma_c89.lower()
+
+
+def test_ccode_functions2():
+    assert ccode(ceiling(x)) == "ceil(x)"
+    assert ccode(Abs(x)) == "fabs(x)"
+    assert ccode(gamma(x)) == "tgamma(x)"
+    r, s = symbols('r,s', real=True)
+    assert ccode(Mod(ceiling(r), ceiling(s))) == '((ceil(r) % ceil(s)) + '\
+                                                 'ceil(s)) % ceil(s)'
+    assert ccode(Mod(r, s)) == "fmod(r, s)"
+    p1, p2 = symbols('p1 p2', integer=True, positive=True)
+    assert ccode(Mod(p1, p2)) == 'p1 % p2'
+    assert ccode(Mod(p1, p2 + 3)) == 'p1 % (p2 + 3)'
+    assert ccode(Mod(-3, -7, evaluate=False)) == '(-3) % (-7)'
+    assert ccode(-Mod(3, 7, evaluate=False)) == '-(3 % 7)'
+    assert ccode(r*Mod(p1, p2)) == 'r*(p1 % p2)'
+    assert ccode(Mod(p1, p2)**s) == 'pow(p1 % p2, s)'
+    n = symbols('n', integer=True, negative=True)
+    assert ccode(Mod(-n, p2)) == '(-n) % p2'
+    assert ccode(fibonacci(n)) == '(1.0/5.0)*pow(2, -n)*sqrt(5)*(-pow(1 - sqrt(5), n) + pow(1 + sqrt(5), n))'
+    assert ccode(lucas(n)) == 'pow(2, -n)*(pow(1 - sqrt(5), n) + pow(1 + sqrt(5), n))'
+
+
+def test_ccode_user_functions():
+    x = symbols('x', integer=False)
+    n = symbols('n', integer=True)
+    custom_functions = {
+        "ceiling": "ceil",
+        "Abs": [(lambda x: not x.is_integer, "fabs"), (lambda x: x.is_integer, "abs")],
+    }
+    assert ccode(ceiling(x), user_functions=custom_functions) == "ceil(x)"
+    assert ccode(Abs(x), user_functions=custom_functions) == "fabs(x)"
+    assert ccode(Abs(n), user_functions=custom_functions) == "abs(n)"
+
+    expr = Symbol('a')
+    muladd = Function('muladd')
+    for i in range(0, 100):
+        # the large number of terms acts as a regression test for gh-23839
+        expr = muladd(Rational(1, 2), Symbol(f'a{i}'), expr)
+    out = ccode(expr, user_functions={'muladd':'muladd'})
+    assert 'a99' in out
+    assert out.count('muladd') == 100
+
+
+def test_ccode_boolean():
+    assert ccode(True) == "true"
+    assert ccode(S.true) == "true"
+    assert ccode(False) == "false"
+    assert ccode(S.false) == "false"
+    assert ccode(x & y) == "x && y"
+    assert ccode(x | y) == "x || y"
+    assert ccode(~x) == "!x"
+    assert ccode(x & y & z) == "x && y && z"
+    assert ccode(x | y | z) == "x || y || z"
+    assert ccode((x & y) | z) == "z || x && y"
+    assert ccode((x | y) & z) == "z && (x || y)"
+    # Automatic rewrites
+    assert ccode(x ^ y) == '(x || y) && (!x || !y)'
+    assert ccode((x ^ y) ^ z) == '(x || y || z) && (x || !y || !z) && (y || !x || !z) && (z || !x || !y)'
+    assert ccode(Implies(x, y)) == 'y || !x'
+    assert ccode(Equivalent(x, z ^ y, Implies(z, x))) == '(x || (y || !z) && (z || !y)) && (z && !x || (y || z) && (!y || !z))'
+
+
+def test_ccode_Relational():
+    assert ccode(Eq(x, y)) == "x == y"
+    assert ccode(Ne(x, y)) == "x != y"
+    assert ccode(Le(x, y)) == "x <= y"
+    assert ccode(Lt(x, y)) == "x < y"
+    assert ccode(Gt(x, y)) == "x > y"
+    assert ccode(Ge(x, y)) == "x >= y"
+
+
+def test_ccode_Piecewise():
+    expr = Piecewise((x, x < 1), (x**2, True))
+    assert ccode(expr) == (
+            "((x < 1) ? (\n"
+            "   x\n"
+            ")\n"
+            ": (\n"
+            "   pow(x, 2)\n"
+            "))")
+    assert ccode(expr, assign_to="c") == (
+            "if (x < 1) {\n"
+            "   c = x;\n"
+            "}\n"
+            "else {\n"
+            "   c = pow(x, 2);\n"
+            "}")
+    expr = Piecewise((x, x < 1), (x + 1, x < 2), (x**2, True))
+    assert ccode(expr) == (
+            "((x < 1) ? (\n"
+            "   x\n"
+            ")\n"
+            ": ((x < 2) ? (\n"
+            "   x + 1\n"
+            ")\n"
+            ": (\n"
+            "   pow(x, 2)\n"
+            ")))")
+    assert ccode(expr, assign_to='c') == (
+            "if (x < 1) {\n"
+            "   c = x;\n"
+            "}\n"
+            "else if (x < 2) {\n"
+            "   c = x + 1;\n"
+            "}\n"
+            "else {\n"
+            "   c = pow(x, 2);\n"
+            "}")
+    # Check that Piecewise without a True (default) condition error
+    expr = Piecewise((x, x < 1), (x**2, x > 1), (sin(x), x > 0))
+    raises(ValueError, lambda: ccode(expr))
+
+
+def test_ccode_sinc():
+    from sympy.functions.elementary.trigonometric import sinc
+    expr = sinc(x)
+    assert ccode(expr) == (
+            "((x != 0) ? (\n"
+            "   sin(x)/x\n"
+            ")\n"
+            ": (\n"
+            "   1\n"
+            "))")
+
+
+def test_ccode_Piecewise_deep():
+    p = ccode(2*Piecewise((x, x < 1), (x + 1, x < 2), (x**2, True)))
+    assert p == (
+            "2*((x < 1) ? (\n"
+            "   x\n"
+            ")\n"
+            ": ((x < 2) ? (\n"
+            "   x + 1\n"
+            ")\n"
+            ": (\n"
+            "   pow(x, 2)\n"
+            ")))")
+    expr = x*y*z + x**2 + y**2 + Piecewise((0, x < 0.5), (1, True)) + cos(z) - 1
+    assert ccode(expr) == (
+            "pow(x, 2) + x*y*z + pow(y, 2) + ((x < 0.5) ? (\n"
+            "   0\n"
+            ")\n"
+            ": (\n"
+            "   1\n"
+            ")) + cos(z) - 1")
+    assert ccode(expr, assign_to='c') == (
+            "c = pow(x, 2) + x*y*z + pow(y, 2) + ((x < 0.5) ? (\n"
+            "   0\n"
+            ")\n"
+            ": (\n"
+            "   1\n"
+            ")) + cos(z) - 1;")
+
+
+def test_ccode_ITE():
+    expr = ITE(x < 1, y, z)
+    assert ccode(expr) == (
+            "((x < 1) ? (\n"
+            "   y\n"
+            ")\n"
+            ": (\n"
+            "   z\n"
+            "))")
+
+
+def test_ccode_settings():
+    raises(TypeError, lambda: ccode(sin(x), method="garbage"))
+
+
+def test_ccode_Indexed():
+    s, n, m, o = symbols('s n m o', integer=True)
+    i, j, k = Idx('i', n), Idx('j', m), Idx('k', o)
+
+    x = IndexedBase('x')[j]
+    A = IndexedBase('A')[i, j]
+    B = IndexedBase('B')[i, j, k]
+
+    p = C99CodePrinter()
+
+    assert p._print_Indexed(x) == 'x[j]'
+    assert p._print_Indexed(A) == 'A[%s]' % (m*i+j)
+    assert p._print_Indexed(B) == 'B[%s]' % (i*o*m+j*o+k)
+
+    A = IndexedBase('A', shape=(5,3))[i, j]
+    assert p._print_Indexed(A) == 'A[%s]' % (3*i + j)
+
+    A = IndexedBase('A', shape=(5,3), strides='F')[i, j]
+    assert ccode(A) == 'A[%s]' % (i + 5*j)
+
+    A = IndexedBase('A', shape=(29,29), strides=(1, s), offset=o)[i, j]
+    assert ccode(A) == 'A[o + s*j + i]'
+
+    Abase = IndexedBase('A', strides=(s, m, n), offset=o)
+    assert ccode(Abase[i, j, k]) == 'A[m*j + n*k + o + s*i]'
+    assert ccode(Abase[2, 3, k]) == 'A[3*m + n*k + o + 2*s]'
+
+
+def test_Element():
+    assert ccode(Element('x', 'ij')) == 'x[i][j]'
+    assert ccode(Element('x', 'ij', strides='kl', offset='o')) == 'x[i*k + j*l + o]'
+    assert ccode(Element('x', (3,))) == 'x[3]'
+    assert ccode(Element('x', (3,4,5))) == 'x[3][4][5]'
+
+
+def test_ccode_Indexed_without_looking_for_contraction():
+    len_y = 5
+    y = IndexedBase('y', shape=(len_y,))
+    x = IndexedBase('x', 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])/(x[i+1]-x[i]))
+    code0 = ccode(e.rhs, assign_to=e.lhs, contract=False)
+    assert code0 == 'Dy[i] = (y[%s] - y[i])/(x[%s] - x[i]);' % (i + 1, i + 1)
+
+
+def test_ccode_loops_matrix_vector():
+    n, m = symbols('n m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+
+    s = (
+        'for (int i=0; i<m; i++){\n'
+        '   y[i] = 0;\n'
+        '}\n'
+        'for (int i=0; i<m; i++){\n'
+        '   for (int j=0; j<n; j++){\n'
+        '      y[i] = A[%s]*x[j] + y[i];\n' % (i*n + j) +\
+        '   }\n'
+        '}'
+    )
+    assert ccode(A[i, j]*x[j], assign_to=y[i]) == s
+
+
+def test_dummy_loops():
+    i, m = symbols('i m', integer=True, cls=Dummy)
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx(i, m)
+
+    expected = (
+        'for (int i_%(icount)i=0; i_%(icount)i<m_%(mcount)i; i_%(icount)i++){\n'
+        '   y[i_%(icount)i] = x[i_%(icount)i];\n'
+        '}'
+    ) % {'icount': i.label.dummy_index, 'mcount': m.dummy_index}
+
+    assert ccode(x[i], assign_to=y[i]) == expected
+
+
+def test_ccode_loops_add():
+    n, m = symbols('n m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    z = IndexedBase('z')
+    i = Idx('i', m)
+    j = Idx('j', n)
+
+    s = (
+        'for (int i=0; i<m; i++){\n'
+        '   y[i] = x[i] + z[i];\n'
+        '}\n'
+        'for (int i=0; i<m; i++){\n'
+        '   for (int j=0; j<n; j++){\n'
+        '      y[i] = A[%s]*x[j] + y[i];\n' % (i*n + j) +\
+        '   }\n'
+        '}'
+    )
+    assert ccode(A[i, j]*x[j] + x[i] + z[i], assign_to=y[i]) == s
+
+
+def test_ccode_loops_multiple_contractions():
+    n, m, o, p = symbols('n m o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+    l = Idx('l', p)
+
+    s = (
+        'for (int i=0; i<m; i++){\n'
+        '   y[i] = 0;\n'
+        '}\n'
+        'for (int i=0; i<m; i++){\n'
+        '   for (int j=0; j<n; j++){\n'
+        '      for (int k=0; k<o; k++){\n'
+        '         for (int l=0; l<p; l++){\n'
+        '            y[i] = a[%s]*b[%s] + y[i];\n' % (i*n*o*p + j*o*p + k*p + l, j*o*p + k*p + l) +\
+        '         }\n'
+        '      }\n'
+        '   }\n'
+        '}'
+    )
+    assert ccode(b[j, k, l]*a[i, j, k, l], assign_to=y[i]) == s
+
+
+def test_ccode_loops_addfactor():
+    n, m, o, p = symbols('n m o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    c = IndexedBase('c')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+    l = Idx('l', p)
+
+    s = (
+        'for (int i=0; i<m; i++){\n'
+        '   y[i] = 0;\n'
+        '}\n'
+        'for (int i=0; i<m; i++){\n'
+        '   for (int j=0; j<n; j++){\n'
+        '      for (int k=0; k<o; k++){\n'
+        '         for (int l=0; l<p; l++){\n'
+        '            y[i] = (a[%s] + b[%s])*c[%s] + y[i];\n' % (i*n*o*p + j*o*p + k*p + l, i*n*o*p + j*o*p + k*p + l, j*o*p + k*p + l) +\
+        '         }\n'
+        '      }\n'
+        '   }\n'
+        '}'
+    )
+    assert ccode((a[i, j, k, l] + b[i, j, k, l])*c[j, k, l], assign_to=y[i]) == s
+
+
+def test_ccode_loops_multiple_terms():
+    n, m, o, p = symbols('n m o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    c = IndexedBase('c')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+
+    s0 = (
+        'for (int i=0; i<m; i++){\n'
+        '   y[i] = 0;\n'
+        '}\n'
+    )
+    s1 = (
+        'for (int i=0; i<m; i++){\n'
+        '   for (int j=0; j<n; j++){\n'
+        '      for (int k=0; k<o; k++){\n'
+        '         y[i] = b[j]*b[k]*c[%s] + y[i];\n' % (i*n*o + j*o + k) +\
+        '      }\n'
+        '   }\n'
+        '}\n'
+    )
+    s2 = (
+        'for (int i=0; i<m; i++){\n'
+        '   for (int k=0; k<o; k++){\n'
+        '      y[i] = a[%s]*b[k] + y[i];\n' % (i*o + k) +\
+        '   }\n'
+        '}\n'
+    )
+    s3 = (
+        'for (int i=0; i<m; i++){\n'
+        '   for (int j=0; j<n; j++){\n'
+        '      y[i] = a[%s]*b[j] + y[i];\n' % (i*n + j) +\
+        '   }\n'
+        '}\n'
+    )
+    c = ccode(b[j]*a[i, j] + b[k]*a[i, k] + b[j]*b[k]*c[i, j, k], assign_to=y[i])
+    assert (c == s0 + s1 + s2 + s3[:-1] or
+            c == s0 + s1 + s3 + s2[:-1] or
+            c == s0 + s2 + s1 + s3[:-1] or
+            c == s0 + s2 + s3 + s1[:-1] or
+            c == s0 + s3 + s1 + s2[:-1] or
+            c == s0 + s3 + s2 + s1[:-1])
+
+
+def test_dereference_printing():
+    expr = x + y + sin(z) + z
+    assert ccode(expr, dereference=[z]) == "x + y + (*z) + sin((*z))"
+
+
+def test_Matrix_printing():
+    # Test returning a Matrix
+    mat = Matrix([x*y, Piecewise((2 + x, y>0), (y, True)), sin(z)])
+    A = MatrixSymbol('A', 3, 1)
+    assert ccode(mat, A) == (
+        "A[0] = x*y;\n"
+        "if (y > 0) {\n"
+        "   A[1] = x + 2;\n"
+        "}\n"
+        "else {\n"
+        "   A[1] = y;\n"
+        "}\n"
+        "A[2] = sin(z);")
+    # Test using MatrixElements in expressions
+    expr = Piecewise((2*A[2, 0], x > 0), (A[2, 0], True)) + sin(A[1, 0]) + A[0, 0]
+    assert ccode(expr) == (
+        "((x > 0) ? (\n"
+        "   2*A[2]\n"
+        ")\n"
+        ": (\n"
+        "   A[2]\n"
+        ")) + sin(A[1]) + A[0]")
+    # Test using MatrixElements in a Matrix
+    q = MatrixSymbol('q', 5, 1)
+    M = MatrixSymbol('M', 3, 3)
+    m = Matrix([[sin(q[1,0]), 0, cos(q[2,0])],
+        [q[1,0] + q[2,0], q[3, 0], 5],
+        [2*q[4, 0]/q[1,0], sqrt(q[0,0]) + 4, 0]])
+    assert ccode(m, M) == (
+        "M[0] = sin(q[1]);\n"
+        "M[1] = 0;\n"
+        "M[2] = cos(q[2]);\n"
+        "M[3] = q[1] + q[2];\n"
+        "M[4] = q[3];\n"
+        "M[5] = 5;\n"
+        "M[6] = 2*q[4]/q[1];\n"
+        "M[7] = sqrt(q[0]) + 4;\n"
+        "M[8] = 0;")
+
+
+def test_sparse_matrix():
+    # gh-15791
+    assert 'Not supported in C' in ccode(SparseMatrix([[1, 2, 3]]))
+
+
+def test_ccode_reserved_words():
+    x, y = symbols('x, if')
+    with raises(ValueError):
+        ccode(y**2, error_on_reserved=True, standard='C99')
+    assert ccode(y**2) == 'pow(if_, 2)'
+    assert ccode(x * y**2, dereference=[y]) == 'pow((*if_), 2)*x'
+    assert ccode(y**2, reserved_word_suffix='_unreserved') == 'pow(if_unreserved, 2)'
+
+
+def test_ccode_sign():
+    expr1, ref1 = sign(x) * y, 'y*(((x) > 0) - ((x) < 0))'
+    expr2, ref2 = sign(cos(x)), '(((cos(x)) > 0) - ((cos(x)) < 0))'
+    expr3, ref3 = sign(2 * x + x**2) * x + x**2, 'pow(x, 2) + x*(((pow(x, 2) + 2*x) > 0) - ((pow(x, 2) + 2*x) < 0))'
+    assert ccode(expr1) == ref1
+    assert ccode(expr1, 'z') == 'z = %s;' % ref1
+    assert ccode(expr2) == ref2
+    assert ccode(expr3) == ref3
+
+def test_ccode_Assignment():
+    assert ccode(Assignment(x, y + z)) == 'x = y + z;'
+    assert ccode(aug_assign(x, '+', y + z)) == 'x += y + z;'
+
+
+def test_ccode_For():
+    f = For(x, Range(0, 10, 2), [aug_assign(y, '*', x)])
+    assert ccode(f) == ("for (x = 0; x < 10; x += 2) {\n"
+                        "   y *= x;\n"
+                        "}")
+
+def test_ccode_Max_Min():
+    assert ccode(Max(x, 0), standard='C89') == '((0 > x) ? 0 : x)'
+    assert ccode(Max(x, 0), standard='C99') == 'fmax(0, x)'
+    assert ccode(Min(x, 0, sqrt(x)), standard='c89') == (
+        '((0 < ((x < sqrt(x)) ? x : sqrt(x))) ? 0 : ((x < sqrt(x)) ? x : sqrt(x)))'
+    )
+
+def test_ccode_standard():
+    assert ccode(expm1(x), standard='c99') == 'expm1(x)'
+    assert ccode(nan, standard='c99') == 'NAN'
+    assert ccode(float('nan'), standard='c99') == 'NAN'
+
+
+def test_C89CodePrinter():
+    c89printer = C89CodePrinter()
+    assert c89printer.language == 'C'
+    assert c89printer.standard == 'C89'
+    assert 'void' in c89printer.reserved_words
+    assert 'template' not in c89printer.reserved_words
+
+
+def test_C99CodePrinter():
+    assert C99CodePrinter().doprint(expm1(x)) == 'expm1(x)'
+    assert C99CodePrinter().doprint(log1p(x)) == 'log1p(x)'
+    assert C99CodePrinter().doprint(exp2(x)) == 'exp2(x)'
+    assert C99CodePrinter().doprint(log2(x)) == 'log2(x)'
+    assert C99CodePrinter().doprint(fma(x, y, -z)) == 'fma(x, y, -z)'
+    assert C99CodePrinter().doprint(log10(x)) == 'log10(x)'
+    assert C99CodePrinter().doprint(Cbrt(x)) == 'cbrt(x)'  # note Cbrt due to cbrt already taken.
+    assert C99CodePrinter().doprint(hypot(x, y)) == 'hypot(x, y)'
+    assert C99CodePrinter().doprint(loggamma(x)) == 'lgamma(x)'
+    assert C99CodePrinter().doprint(Max(x, 3, x**2)) == 'fmax(3, fmax(x, pow(x, 2)))'
+    assert C99CodePrinter().doprint(Min(x, 3)) == 'fmin(3, x)'
+    c99printer = C99CodePrinter()
+    assert c99printer.language == 'C'
+    assert c99printer.standard == 'C99'
+    assert 'restrict' in c99printer.reserved_words
+    assert 'using' not in c99printer.reserved_words
+
+
+@XFAIL
+def test_C99CodePrinter__precision_f80():
+    f80_printer = C99CodePrinter({"type_aliases": {real: float80}})
+    assert f80_printer.doprint(sin(x+Float('2.1'))) == 'sinl(x + 2.1L)'
+
+
+def test_C99CodePrinter__precision():
+    n = symbols('n', integer=True)
+    p = symbols('p', integer=True, positive=True)
+    f32_printer = C99CodePrinter({"type_aliases": {real: float32}})
+    f64_printer = C99CodePrinter({"type_aliases": {real: float64}})
+    f80_printer = C99CodePrinter({"type_aliases": {real: float80}})
+    assert f32_printer.doprint(sin(x+2.1)) == 'sinf(x + 2.1F)'
+    assert f64_printer.doprint(sin(x+2.1)) == 'sin(x + 2.1000000000000001)'
+    assert f80_printer.doprint(sin(x+Float('2.0'))) == 'sinl(x + 2.0L)'
+
+    for printer, suffix in zip([f32_printer, f64_printer, f80_printer], ['f', '', 'l']):
+        def check(expr, ref):
+            assert printer.doprint(expr) == ref.format(s=suffix, S=suffix.upper())
+        check(Abs(n), 'abs(n)')
+        check(Abs(x + 2.0), 'fabs{s}(x + 2.0{S})')
+        check(sin(x + 4.0)**cos(x - 2.0), 'pow{s}(sin{s}(x + 4.0{S}), cos{s}(x - 2.0{S}))')
+        check(exp(x*8.0), 'exp{s}(8.0{S}*x)')
+        check(exp2(x), 'exp2{s}(x)')
+        check(expm1(x*4.0), 'expm1{s}(4.0{S}*x)')
+        check(Mod(p, 2), 'p % 2')
+        check(Mod(2*p + 3, 3*p + 5, evaluate=False), '(2*p + 3) % (3*p + 5)')
+        check(Mod(x + 2.0, 3.0), 'fmod{s}(1.0{S}*x + 2.0{S}, 3.0{S})')
+        check(Mod(x, 2.0*x + 3.0), 'fmod{s}(1.0{S}*x, 2.0{S}*x + 3.0{S})')
+        check(log(x/2), 'log{s}((1.0{S}/2.0{S})*x)')
+        check(log10(3*x/2), 'log10{s}((3.0{S}/2.0{S})*x)')
+        check(log2(x*8.0), 'log2{s}(8.0{S}*x)')
+        check(log1p(x), 'log1p{s}(x)')
+        check(2**x, 'pow{s}(2, x)')
+        check(2.0**x, 'pow{s}(2.0{S}, x)')
+        check(x**3, 'pow{s}(x, 3)')
+        check(x**4.0, 'pow{s}(x, 4.0{S})')
+        check(sqrt(3+x), 'sqrt{s}(x + 3)')
+        check(Cbrt(x-2.0), 'cbrt{s}(x - 2.0{S})')
+        check(hypot(x, y), 'hypot{s}(x, y)')
+        check(sin(3.*x + 2.), 'sin{s}(3.0{S}*x + 2.0{S})')
+        check(cos(3.*x - 1.), 'cos{s}(3.0{S}*x - 1.0{S})')
+        check(tan(4.*y + 2.), 'tan{s}(4.0{S}*y + 2.0{S})')
+        check(asin(3.*x + 2.), 'asin{s}(3.0{S}*x + 2.0{S})')
+        check(acos(3.*x + 2.), 'acos{s}(3.0{S}*x + 2.0{S})')
+        check(atan(3.*x + 2.), 'atan{s}(3.0{S}*x + 2.0{S})')
+        check(atan2(3.*x, 2.*y), 'atan2{s}(3.0{S}*x, 2.0{S}*y)')
+
+        check(sinh(3.*x + 2.), 'sinh{s}(3.0{S}*x + 2.0{S})')
+        check(cosh(3.*x - 1.), 'cosh{s}(3.0{S}*x - 1.0{S})')
+        check(tanh(4.0*y + 2.), 'tanh{s}(4.0{S}*y + 2.0{S})')
+        check(asinh(3.*x + 2.), 'asinh{s}(3.0{S}*x + 2.0{S})')
+        check(acosh(3.*x + 2.), 'acosh{s}(3.0{S}*x + 2.0{S})')
+        check(atanh(3.*x + 2.), 'atanh{s}(3.0{S}*x + 2.0{S})')
+        check(erf(42.*x), 'erf{s}(42.0{S}*x)')
+        check(erfc(42.*x), 'erfc{s}(42.0{S}*x)')
+        check(gamma(x), 'tgamma{s}(x)')
+        check(loggamma(x), 'lgamma{s}(x)')
+
+        check(ceiling(x + 2.), "ceil{s}(x + 2.0{S})")
+        check(floor(x + 2.), "floor{s}(x + 2.0{S})")
+        check(fma(x, y, -z), 'fma{s}(x, y, -z)')
+        check(Max(x, 8.0, x**4.0), 'fmax{s}(8.0{S}, fmax{s}(x, pow{s}(x, 4.0{S})))')
+        check(Min(x, 2.0), 'fmin{s}(2.0{S}, x)')
+
+
+def test_get_math_macros():
+    macros = get_math_macros()
+    assert macros[exp(1)] == 'M_E'
+    assert macros[1/Sqrt(2)] == 'M_SQRT1_2'
+
+
+def test_ccode_Declaration():
+    i = symbols('i', integer=True)
+    var1 = Variable(i, type=Type.from_expr(i))
+    dcl1 = Declaration(var1)
+    assert ccode(dcl1) == 'int i'
+
+    var2 = Variable(x, type=float32, attrs={value_const})
+    dcl2a = Declaration(var2)
+    assert ccode(dcl2a) == 'const float x'
+    dcl2b = var2.as_Declaration(value=pi)
+    assert ccode(dcl2b) == 'const float x = M_PI'
+
+    var3 = Variable(y, type=Type('bool'))
+    dcl3 = Declaration(var3)
+    printer = C89CodePrinter()
+    assert 'stdbool.h' not in printer.headers
+    assert printer.doprint(dcl3) == 'bool y'
+    assert 'stdbool.h' in printer.headers
+
+    u = symbols('u', real=True)
+    ptr4 = Pointer.deduced(u, attrs={pointer_const, restrict})
+    dcl4 = Declaration(ptr4)
+    assert ccode(dcl4) == 'double * const restrict u'
+
+    var5 = Variable(x, Type('__float128'), attrs={value_const})
+    dcl5a = Declaration(var5)
+    assert ccode(dcl5a) == 'const __float128 x'
+    var5b = Variable(var5.symbol, var5.type, pi, attrs=var5.attrs)
+    dcl5b = Declaration(var5b)
+    assert ccode(dcl5b) == 'const __float128 x = M_PI'
+
+
+def test_C99CodePrinter_custom_type():
+    # We will look at __float128 (new in glibc 2.26)
+    f128 = FloatType('_Float128', float128.nbits, float128.nmant, float128.nexp)
+    p128 = C99CodePrinter({
+        "type_aliases": {real: f128},
+        "type_literal_suffixes": {f128: 'Q'},
+        "type_func_suffixes": {f128: 'f128'},
+        "type_math_macro_suffixes": {
+            real: 'f128',
+            f128: 'f128'
+        },
+        "type_macros": {
+            f128: ('__STDC_WANT_IEC_60559_TYPES_EXT__',)
+        }
+    })
+    assert p128.doprint(x) == 'x'
+    assert not p128.headers
+    assert not p128.libraries
+    assert not p128.macros
+    assert p128.doprint(2.0) == '2.0Q'
+    assert not p128.headers
+    assert not p128.libraries
+    assert p128.macros == {'__STDC_WANT_IEC_60559_TYPES_EXT__'}
+
+    assert p128.doprint(Rational(1, 2)) == '1.0Q/2.0Q'
+    assert p128.doprint(sin(x)) == 'sinf128(x)'
+    assert p128.doprint(cos(2., evaluate=False)) == 'cosf128(2.0Q)'
+    assert p128.doprint(x**-1.0) == '1.0Q/x'
+
+    var5 = Variable(x, f128, attrs={value_const})
+
+    dcl5a = Declaration(var5)
+    assert ccode(dcl5a) == 'const _Float128 x'
+    var5b = Variable(x, f128, pi, attrs={value_const})
+    dcl5b = Declaration(var5b)
+    assert p128.doprint(dcl5b) == 'const _Float128 x = M_PIf128'
+    var5b = Variable(x, f128, value=Catalan.evalf(38), attrs={value_const})
+    dcl5c = Declaration(var5b)
+    assert p128.doprint(dcl5c) == 'const _Float128 x = %sQ' % Catalan.evalf(f128.decimal_dig)
+
+
+def test_MatrixElement_printing():
+    # test cases for issue #11821
+    A = MatrixSymbol("A", 1, 3)
+    B = MatrixSymbol("B", 1, 3)
+    C = MatrixSymbol("C", 1, 3)
+
+    assert(ccode(A[0, 0]) == "A[0]")
+    assert(ccode(3 * A[0, 0]) == "3*A[0]")
+
+    F = C[0, 0].subs(C, A - B)
+    assert(ccode(F) == "(A - B)[0]")
+
+def test_ccode_math_macros():
+    assert ccode(z + exp(1)) == 'z + M_E'
+    assert ccode(z + log2(exp(1))) == 'z + M_LOG2E'
+    assert ccode(z + 1/log(2)) == 'z + M_LOG2E'
+    assert ccode(z + log(2)) == 'z + M_LN2'
+    assert ccode(z + log(10)) == 'z + M_LN10'
+    assert ccode(z + pi) == 'z + M_PI'
+    assert ccode(z + pi/2) == 'z + M_PI_2'
+    assert ccode(z + pi/4) == 'z + M_PI_4'
+    assert ccode(z + 1/pi) == 'z + M_1_PI'
+    assert ccode(z + 2/pi) == 'z + M_2_PI'
+    assert ccode(z + 2/sqrt(pi)) == 'z + M_2_SQRTPI'
+    assert ccode(z + 2/Sqrt(pi)) == 'z + M_2_SQRTPI'
+    assert ccode(z + sqrt(2)) == 'z + M_SQRT2'
+    assert ccode(z + Sqrt(2)) == 'z + M_SQRT2'
+    assert ccode(z + 1/sqrt(2)) == 'z + M_SQRT1_2'
+    assert ccode(z + 1/Sqrt(2)) == 'z + M_SQRT1_2'
+
+
+def test_ccode_Type():
+    assert ccode(Type('float')) == 'float'
+    assert ccode(intc) == 'int'
+
+
+def test_ccode_codegen_ast():
+    # Note that C only allows comments of the form /* ... */, double forward
+    # slash is not standard C, and some C compilers will grind to a halt upon
+    # encountering them.
+    assert ccode(Comment("this is a comment")) == "/* this is a comment */"  # not //
+    assert ccode(While(abs(x) > 1, [aug_assign(x, '-', 1)])) == (
+        'while (fabs(x) > 1) {\n'
+        '   x -= 1;\n'
+        '}'
+    )
+    assert ccode(Scope([AddAugmentedAssignment(x, 1)])) == (
+        '{\n'
+        '   x += 1;\n'
+        '}'
+    )
+    inp_x = Declaration(Variable(x, type=real))
+    assert ccode(FunctionPrototype(real, 'pwer', [inp_x])) == 'double pwer(double x)'
+    assert ccode(FunctionDefinition(real, 'pwer', [inp_x], [Assignment(x, x**2)])) == (
+        'double pwer(double x){\n'
+        '   x = pow(x, 2);\n'
+        '}'
+    )
+
+    # Elements of CodeBlock are formatted as statements:
+    block = CodeBlock(
+        x,
+        Print([x, y], "%d %d"),
+        FunctionCall('pwer', [x]),
+        Return(x),
+    )
+    assert ccode(block) == '\n'.join([
+        'x;',
+        'printf("%d %d", x, y);',
+        'pwer(x);',
+        'return x;',
+    ])
+
+def test_ccode_UnevaluatedExpr():
+    assert ccode(UnevaluatedExpr(y * x) + z) == "z + x*y"
+    assert ccode(UnevaluatedExpr(y + x) + z) == "z + (x + y)"  # gh-21955
+    w = symbols('w')
+    assert ccode(UnevaluatedExpr(y + x) + UnevaluatedExpr(z + w)) == "(w + z) + (x + y)"
+
+    p, q, r = symbols("p q r", real=True)
+    q_r = UnevaluatedExpr(q + r)
+    expr = abs(exp(p+q_r))
+    assert ccode(expr) == "exp(p + (q + r))"
+
+
+def test_ccode_array_like_containers():
+    assert ccode([2,3,4]) == "{2, 3, 4}"
+    assert ccode((2,3,4)) == "{2, 3, 4}"

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_codeprinter.py

@@ -0,0 +1,55 @@
+from sympy.printing.codeprinter import CodePrinter
+from sympy.core import symbols
+from sympy.core.symbol import Dummy
+from sympy.testing.pytest import raises
+
+
+def setup_test_printer(**kwargs):
+    p = CodePrinter(settings=kwargs)
+    p._not_supported = set()
+    p._number_symbols = set()
+    return p
+
+
+def test_print_Dummy():
+    d = Dummy('d')
+    p = setup_test_printer()
+    assert p._print_Dummy(d) == "d_%i" % d.dummy_index
+
+def test_print_Symbol():
+
+    x, y = symbols('x, if')
+
+    p = setup_test_printer()
+    assert p._print(x) == 'x'
+    assert p._print(y) == 'if'
+
+    p.reserved_words.update(['if'])
+    assert p._print(y) == 'if_'
+
+    p = setup_test_printer(error_on_reserved=True)
+    p.reserved_words.update(['if'])
+    with raises(ValueError):
+        p._print(y)
+
+    p = setup_test_printer(reserved_word_suffix='_He_Man')
+    p.reserved_words.update(['if'])
+    assert p._print(y) == 'if_He_Man'
+
+def test_issue_15791():
+    class CrashingCodePrinter(CodePrinter):
+        def emptyPrinter(self, obj):
+            raise NotImplementedError
+
+    from sympy.matrices import (
+        MutableSparseMatrix,
+        ImmutableSparseMatrix,
+    )
+
+    c = CrashingCodePrinter()
+
+    # these should not silently succeed
+    with raises(NotImplementedError):
+        c.doprint(ImmutableSparseMatrix(2, 2, {}))
+    with raises(NotImplementedError):
+        c.doprint(MutableSparseMatrix(2, 2, {}))

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_conventions.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+
+from sympy.core.function import (Derivative, Function)
+from sympy.core.numbers import oo
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.trigonometric import cos
+from sympy.integrals.integrals import Integral
+from sympy.functions.special.bessel import besselj
+from sympy.functions.special.polynomials import legendre
+from sympy.functions.combinatorial.numbers import bell
+from sympy.printing.conventions import split_super_sub, requires_partial
+from sympy.testing.pytest import XFAIL
+
+def test_super_sub():
+    assert split_super_sub("beta_13_2") == ("beta", [], ["13", "2"])
+    assert split_super_sub("beta_132_20") == ("beta", [], ["132", "20"])
+    assert split_super_sub("beta_13") == ("beta", [], ["13"])
+    assert split_super_sub("x_a_b") == ("x", [], ["a", "b"])
+    assert split_super_sub("x_1_2_3") == ("x", [], ["1", "2", "3"])
+    assert split_super_sub("x_a_b1") == ("x", [], ["a", "b1"])
+    assert split_super_sub("x_a_1") == ("x", [], ["a", "1"])
+    assert split_super_sub("x_1_a") == ("x", [], ["1", "a"])
+    assert split_super_sub("x_1^aa") == ("x", ["aa"], ["1"])
+    assert split_super_sub("x_1__aa") == ("x", ["aa"], ["1"])
+    assert split_super_sub("x_11^a") == ("x", ["a"], ["11"])
+    assert split_super_sub("x_11__a") == ("x", ["a"], ["11"])
+    assert split_super_sub("x_a_b_c_d") == ("x", [], ["a", "b", "c", "d"])
+    assert split_super_sub("x_a_b^c^d") == ("x", ["c", "d"], ["a", "b"])
+    assert split_super_sub("x_a_b__c__d") == ("x", ["c", "d"], ["a", "b"])
+    assert split_super_sub("x_a^b_c^d") == ("x", ["b", "d"], ["a", "c"])
+    assert split_super_sub("x_a__b_c__d") == ("x", ["b", "d"], ["a", "c"])
+    assert split_super_sub("x^a^b_c_d") == ("x", ["a", "b"], ["c", "d"])
+    assert split_super_sub("x__a__b_c_d") == ("x", ["a", "b"], ["c", "d"])
+    assert split_super_sub("x^a^b^c^d") == ("x", ["a", "b", "c", "d"], [])
+    assert split_super_sub("x__a__b__c__d") == ("x", ["a", "b", "c", "d"], [])
+    assert split_super_sub("alpha_11") == ("alpha", [], ["11"])
+    assert split_super_sub("alpha_11_11") == ("alpha", [], ["11", "11"])
+    assert split_super_sub("w1") == ("w", [], ["1"])
+    assert split_super_sub("w𝟙") == ("w", [], ["𝟙"])
+    assert split_super_sub("w11") == ("w", [], ["11"])
+    assert split_super_sub("w𝟙𝟙") == ("w", [], ["𝟙𝟙"])
+    assert split_super_sub("w𝟙2𝟙") == ("w", [], ["𝟙2𝟙"])
+    assert split_super_sub("w1^a") == ("w", ["a"], ["1"])
+    assert split_super_sub("ω1") == ("ω", [], ["1"])
+    assert split_super_sub("ω11") == ("ω", [], ["11"])
+    assert split_super_sub("ω1^a") == ("ω", ["a"], ["1"])
+    assert split_super_sub("ω𝟙^α") == ("ω", ["α"], ["𝟙"])
+    assert split_super_sub("ω𝟙2^3α") == ("ω", ["3α"], ["𝟙2"])
+    assert split_super_sub("") == ("", [], [])
+
+
+def test_requires_partial():
+    x, y, z, t, nu = symbols('x y z t nu')
+    n = symbols('n', integer=True)
+
+    f = x * y
+    assert requires_partial(Derivative(f, x)) is True
+    assert requires_partial(Derivative(f, y)) is True
+
+    ## integrating out one of the variables
+    assert requires_partial(Derivative(Integral(exp(-x * y), (x, 0, oo)), y, evaluate=False)) is False
+
+    ## bessel function with smooth parameter
+    f = besselj(nu, x)
+    assert requires_partial(Derivative(f, x)) is True
+    assert requires_partial(Derivative(f, nu)) is True
+
+    ## bessel function with integer parameter
+    f = besselj(n, x)
+    assert requires_partial(Derivative(f, x)) is False
+    # this is not really valid (differentiating with respect to an integer)
+    # but there's no reason to use the partial derivative symbol there. make
+    # sure we don't throw an exception here, though
+    assert requires_partial(Derivative(f, n)) is False
+
+    ## bell polynomial
+    f = bell(n, x)
+    assert requires_partial(Derivative(f, x)) is False
+    # again, invalid
+    assert requires_partial(Derivative(f, n)) is False
+
+    ## legendre polynomial
+    f = legendre(0, x)
+    assert requires_partial(Derivative(f, x)) is False
+
+    f = legendre(n, x)
+    assert requires_partial(Derivative(f, x)) is False
+    # again, invalid
+    assert requires_partial(Derivative(f, n)) is False
+
+    f = x ** n
+    assert requires_partial(Derivative(f, x)) is False
+
+    assert requires_partial(Derivative(Integral((x*y) ** n * exp(-x * y), (x, 0, oo)), y, evaluate=False)) is False
+
+    # parametric equation
+    f = (exp(t), cos(t))
+    g = sum(f)
+    assert requires_partial(Derivative(g, t)) is False
+
+    f = symbols('f', cls=Function)
+    assert requires_partial(Derivative(f(x), x)) is False
+    assert requires_partial(Derivative(f(x), y)) is False
+    assert requires_partial(Derivative(f(x, y), x)) is True
+    assert requires_partial(Derivative(f(x, y), y)) is True
+    assert requires_partial(Derivative(f(x, y), z)) is True
+    assert requires_partial(Derivative(f(x, y), x, y)) is True
+
+@XFAIL
+def test_requires_partial_unspecified_variables():
+    x, y = symbols('x y')
+    # function of unspecified variables
+    f = symbols('f', cls=Function)
+    assert requires_partial(Derivative(f, x)) is False
+    assert requires_partial(Derivative(f, x, y)) is True

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_cupy.py

@@ -0,0 +1,55 @@
+from sympy.concrete.summations import Sum
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.utilities.lambdify import lambdify
+from sympy.abc import x, i, a, b
+from sympy.codegen.numpy_nodes import logaddexp
+from sympy.printing.numpy import CuPyPrinter, _cupy_known_constants, _cupy_known_functions
+
+from sympy.testing.pytest import skip
+from sympy.external import import_module
+
+cp = import_module('cupy')
+
+def test_cupy_print():
+    prntr = CuPyPrinter()
+    assert prntr.doprint(logaddexp(a, b)) == 'cupy.logaddexp(a, b)'
+    assert prntr.doprint(sqrt(x)) == 'cupy.sqrt(x)'
+    assert prntr.doprint(log(x)) == 'cupy.log(x)'
+    assert prntr.doprint("acos(x)") == 'cupy.arccos(x)'
+    assert prntr.doprint("exp(x)") == 'cupy.exp(x)'
+    assert prntr.doprint("Abs(x)") == 'abs(x)'
+
+def test_not_cupy_print():
+    prntr = CuPyPrinter()
+    assert "Not supported" in prntr.doprint("abcd(x)")
+
+def test_cupy_sum():
+    if not cp:
+        skip("CuPy not installed")
+
+    s = Sum(x ** i, (i, a, b))
+    f = lambdify((a, b, x), s, 'cupy')
+
+    a_, b_ = 0, 10
+    x_ = cp.linspace(-1, +1, 10)
+    assert cp.allclose(f(a_, b_, x_), sum(x_ ** i_ for i_ in range(a_, b_ + 1)))
+
+    s = Sum(i * x, (i, a, b))
+    f = lambdify((a, b, x), s, 'numpy')
+
+    a_, b_ = 0, 10
+    x_ = cp.linspace(-1, +1, 10)
+    assert cp.allclose(f(a_, b_, x_), sum(i_ * x_ for i_ in range(a_, b_ + 1)))
+
+def test_cupy_known_funcs_consts():
+    assert _cupy_known_constants['NaN'] == 'cupy.nan'
+    assert _cupy_known_constants['EulerGamma'] == 'cupy.euler_gamma'
+
+    assert _cupy_known_functions['acos'] == 'cupy.arccos'
+    assert _cupy_known_functions['log'] == 'cupy.log'
+
+def test_cupy_print_methods():
+    prntr = CuPyPrinter()
+    assert hasattr(prntr, '_print_acos')
+    assert hasattr(prntr, '_print_log')

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_cxx.py

@@ -0,0 +1,67 @@
+from sympy.core.symbol import symbols
+from sympy.functions import beta, Ei, zeta, Max, Min, sqrt, riemann_xi, frac
+from sympy.printing.cxx import CXX98CodePrinter, CXX11CodePrinter, CXX17CodePrinter, cxxcode
+from sympy.codegen.cfunctions import log1p
+
+
+x, y, u, v = symbols('x y u v')
+
+
+def test_CXX98CodePrinter():
+    assert CXX98CodePrinter().doprint(Max(x, 3)) in ('std::max(x, 3)', 'std::max(3, x)')
+    assert CXX98CodePrinter().doprint(Min(x, 3, sqrt(x))) == 'std::min(3, std::min(x, std::sqrt(x)))'
+    cxx98printer = CXX98CodePrinter()
+    assert cxx98printer.language == 'C++'
+    assert cxx98printer.standard == 'C++98'
+    assert 'template' in cxx98printer.reserved_words
+    assert 'alignas' not in cxx98printer.reserved_words
+
+
+def test_CXX11CodePrinter():
+    assert CXX11CodePrinter().doprint(log1p(x)) == 'std::log1p(x)'
+
+    cxx11printer = CXX11CodePrinter()
+    assert cxx11printer.language == 'C++'
+    assert cxx11printer.standard == 'C++11'
+    assert 'operator' in cxx11printer.reserved_words
+    assert 'noexcept' in cxx11printer.reserved_words
+    assert 'concept' not in cxx11printer.reserved_words
+
+
+def test_subclass_print_method():
+    class MyPrinter(CXX11CodePrinter):
+        def _print_log1p(self, expr):
+            return 'my_library::log1p(%s)' % ', '.join(map(self._print, expr.args))
+
+    assert MyPrinter().doprint(log1p(x)) == 'my_library::log1p(x)'
+
+
+def test_subclass_print_method__ns():
+    class MyPrinter(CXX11CodePrinter):
+        _ns = 'my_library::'
+
+    p = CXX11CodePrinter()
+    myp = MyPrinter()
+
+    assert p.doprint(log1p(x)) == 'std::log1p(x)'
+    assert myp.doprint(log1p(x)) == 'my_library::log1p(x)'
+
+
+def test_CXX17CodePrinter():
+    assert CXX17CodePrinter().doprint(beta(x, y)) == 'std::beta(x, y)'
+    assert CXX17CodePrinter().doprint(Ei(x)) == 'std::expint(x)'
+    assert CXX17CodePrinter().doprint(zeta(x)) == 'std::riemann_zeta(x)'
+
+    # Automatic rewrite
+    assert CXX17CodePrinter().doprint(frac(x)) == 'x - std::floor(x)'
+    assert CXX17CodePrinter().doprint(riemann_xi(x)) == '(1.0/2.0)*std::pow(M_PI, -1.0/2.0*x)*x*(x - 1)*std::tgamma((1.0/2.0)*x)*std::riemann_zeta(x)'
+
+
+def test_cxxcode():
+    assert sorted(cxxcode(sqrt(x)*.5).split('*')) == sorted(['0.5', 'std::sqrt(x)'])
+
+def test_cxxcode_nested_minmax():
+    assert cxxcode(Max(Min(x, y), Min(u, v))) \
+        == 'std::max(std::min(u, v), std::min(x, y))'
+    assert cxxcode(Min(Max(x, y), Max(u, v))) \
+        == 'std::min(std::max(u, v), std::max(x, y))'

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_dot.py

@@ -0,0 +1,134 @@
+from sympy.printing.dot import (purestr, styleof, attrprint, dotnode,
+        dotedges, dotprint)
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr
+from sympy.core.numbers import (Float, Integer)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.printing.repr import srepr
+from sympy.abc import x
+
+
+def test_purestr():
+    assert purestr(Symbol('x')) == "Symbol('x')"
+    assert purestr(Basic(S(1), S(2))) == "Basic(Integer(1), Integer(2))"
+    assert purestr(Float(2)) == "Float('2.0', precision=53)"
+
+    assert purestr(Symbol('x'), with_args=True) == ("Symbol('x')", ())
+    assert purestr(Basic(S(1), S(2)), with_args=True) == \
+            ('Basic(Integer(1), Integer(2))', ('Integer(1)', 'Integer(2)'))
+    assert purestr(Float(2), with_args=True) == \
+        ("Float('2.0', precision=53)", ())
+
+
+def test_styleof():
+    styles = [(Basic, {'color': 'blue', 'shape': 'ellipse'}),
+              (Expr,  {'color': 'black'})]
+    assert styleof(Basic(S(1)), styles) == {'color': 'blue', 'shape': 'ellipse'}
+
+    assert styleof(x + 1, styles) == {'color': 'black', 'shape': 'ellipse'}
+
+
+def test_attrprint():
+    assert attrprint({'color': 'blue', 'shape': 'ellipse'}) == \
+           '"color"="blue", "shape"="ellipse"'
+
+def test_dotnode():
+
+    assert dotnode(x, repeat=False) == \
+        '"Symbol(\'x\')" ["color"="black", "label"="x", "shape"="ellipse"];'
+    assert dotnode(x+2, repeat=False) == \
+        '"Add(Integer(2), Symbol(\'x\'))" ' \
+        '["color"="black", "label"="Add", "shape"="ellipse"];', \
+        dotnode(x+2,repeat=0)
+
+    assert dotnode(x + x**2, repeat=False) == \
+        '"Add(Symbol(\'x\'), Pow(Symbol(\'x\'), Integer(2)))" ' \
+        '["color"="black", "label"="Add", "shape"="ellipse"];'
+    assert dotnode(x + x**2, repeat=True) == \
+        '"Add(Symbol(\'x\'), Pow(Symbol(\'x\'), Integer(2)))_()" ' \
+        '["color"="black", "label"="Add", "shape"="ellipse"];'
+
+def test_dotedges():
+    assert sorted(dotedges(x+2, repeat=False)) == [
+        '"Add(Integer(2), Symbol(\'x\'))" -> "Integer(2)";',
+        '"Add(Integer(2), Symbol(\'x\'))" -> "Symbol(\'x\')";'
+    ]
+    assert sorted(dotedges(x + 2, repeat=True)) == [
+        '"Add(Integer(2), Symbol(\'x\'))_()" -> "Integer(2)_(0,)";',
+        '"Add(Integer(2), Symbol(\'x\'))_()" -> "Symbol(\'x\')_(1,)";'
+    ]
+
+def test_dotprint():
+    text = dotprint(x+2, repeat=False)
+    assert all(e in text for e in dotedges(x+2, repeat=False))
+    assert all(
+        n in text for n in [dotnode(expr, repeat=False)
+        for expr in (x, Integer(2), x+2)])
+    assert 'digraph' in text
+
+    text = dotprint(x+x**2, repeat=False)
+    assert all(e in text for e in dotedges(x+x**2, repeat=False))
+    assert all(
+        n in text for n in [dotnode(expr, repeat=False)
+        for expr in (x, Integer(2), x**2)])
+    assert 'digraph' in text
+
+    text = dotprint(x+x**2, repeat=True)
+    assert all(e in text for e in dotedges(x+x**2, repeat=True))
+    assert all(
+        n in text for n in [dotnode(expr, pos=())
+        for expr in [x + x**2]])
+
+    text = dotprint(x**x, repeat=True)
+    assert all(e in text for e in dotedges(x**x, repeat=True))
+    assert all(
+        n in text for n in [dotnode(x, pos=(0,)), dotnode(x, pos=(1,))])
+    assert 'digraph' in text
+
+def test_dotprint_depth():
+    text = dotprint(3*x+2, depth=1)
+    assert dotnode(3*x+2) in text
+    assert dotnode(x) not in text
+    text = dotprint(3*x+2)
+    assert "depth" not in text
+
+def test_Matrix_and_non_basics():
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    n = Symbol('n')
+    assert dotprint(MatrixSymbol('X', n, n)) == \
+"""digraph{
+
+# Graph style
+"ordering"="out"
+"rankdir"="TD"
+
+#########
+# Nodes #
+#########
+
+"MatrixSymbol(Str('X'), Symbol('n'), Symbol('n'))_()" ["color"="black", "label"="MatrixSymbol", "shape"="ellipse"];
+"Str('X')_(0,)" ["color"="blue", "label"="X", "shape"="ellipse"];
+"Symbol('n')_(1,)" ["color"="black", "label"="n", "shape"="ellipse"];
+"Symbol('n')_(2,)" ["color"="black", "label"="n", "shape"="ellipse"];
+
+#########
+# Edges #
+#########
+
+"MatrixSymbol(Str('X'), Symbol('n'), Symbol('n'))_()" -> "Str('X')_(0,)";
+"MatrixSymbol(Str('X'), Symbol('n'), Symbol('n'))_()" -> "Symbol('n')_(1,)";
+"MatrixSymbol(Str('X'), Symbol('n'), Symbol('n'))_()" -> "Symbol('n')_(2,)";
+}"""
+
+
+def test_labelfunc():
+    text = dotprint(x + 2, labelfunc=srepr)
+    assert "Symbol('x')" in text
+    assert "Integer(2)" in text
+
+
+def test_commutative():
+    x, y = symbols('x y', commutative=False)
+    assert dotprint(x + y) == dotprint(y + x)
+    assert dotprint(x*y) != dotprint(y*x)

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_fortran.py

@@ -0,0 +1,853 @@
+from sympy.core.add import Add
+from sympy.core.expr import Expr
+from sympy.core.function import (Function, Lambda, diff)
+from sympy.core.mod import Mod
+from sympy.core import (Catalan, EulerGamma, GoldenRatio)
+from sympy.core.numbers import (E, Float, I, Integer, Rational, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import (conjugate, sign)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (atan2, cos, sin)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import Integral
+from sympy.sets.fancysets import Range
+
+from sympy.codegen import For, Assignment, aug_assign
+from sympy.codegen.ast import Declaration, Variable, float32, float64, \
+        value_const, real, bool_, While, FunctionPrototype, FunctionDefinition, \
+        integer, Return, Element
+from sympy.core.expr import UnevaluatedExpr
+from sympy.core.relational import Relational
+from sympy.logic.boolalg import And, Or, Not, Equivalent, Xor
+from sympy.matrices import Matrix, MatrixSymbol
+from sympy.printing.fortran import fcode, FCodePrinter
+from sympy.tensor import IndexedBase, Idx
+from sympy.tensor.array.expressions import ArraySymbol, ArrayElement
+from sympy.utilities.lambdify import implemented_function
+from sympy.testing.pytest import raises
+
+
+def test_UnevaluatedExpr():
+    p, q, r = symbols("p q r", real=True)
+    q_r = UnevaluatedExpr(q + r)
+    expr = abs(exp(p+q_r))
+    assert fcode(expr, source_format="free") == "exp(p + (q + r))"
+    x, y, z = symbols("x y z")
+    y_z = UnevaluatedExpr(y + z)
+    expr2 = abs(exp(x+y_z))
+    assert fcode(expr2, human=False)[2].lstrip() == "exp(re(x) + re(y + z))"
+    assert fcode(expr2, user_functions={"re": "realpart"}).lstrip() == "exp(realpart(x) + realpart(y + z))"
+
+
+def test_printmethod():
+    x = symbols('x')
+
+    class nint(Function):
+        def _fcode(self, printer):
+            return "nint(%s)" % printer._print(self.args[0])
+    assert fcode(nint(x)) == "      nint(x)"
+
+
+def test_fcode_sign():  #issue 12267
+    x=symbols('x')
+    y=symbols('y', integer=True)
+    z=symbols('z', complex=True)
+    assert fcode(sign(x), standard=95, source_format='free') == "merge(0d0, dsign(1d0, x), x == 0d0)"
+    assert fcode(sign(y), standard=95, source_format='free') == "merge(0, isign(1, y), y == 0)"
+    assert fcode(sign(z), standard=95, source_format='free') == "merge(cmplx(0d0, 0d0), z/abs(z), abs(z) == 0d0)"
+    raises(NotImplementedError, lambda: fcode(sign(x)))
+
+
+def test_fcode_Pow():
+    x, y = symbols('x,y')
+    n = symbols('n', integer=True)
+
+    assert fcode(x**3) == "      x**3"
+    assert fcode(x**(y**3)) == "      x**(y**3)"
+    assert fcode(1/(sin(x)*3.5)**(x - y**x)/(x**2 + y)) == \
+        "      (3.5d0*sin(x))**(-x + y**x)/(x**2 + y)"
+    assert fcode(sqrt(x)) == '      sqrt(x)'
+    assert fcode(sqrt(n)) == '      sqrt(dble(n))'
+    assert fcode(x**0.5) == '      sqrt(x)'
+    assert fcode(sqrt(x)) == '      sqrt(x)'
+    assert fcode(sqrt(10)) == '      sqrt(10.0d0)'
+    assert fcode(x**-1.0) == '      1d0/x'
+    assert fcode(x**-2.0, 'y', source_format='free') == 'y = x**(-2.0d0)'  # 2823
+    assert fcode(x**Rational(3, 7)) == '      x**(3.0d0/7.0d0)'
+
+
+def test_fcode_Rational():
+    x = symbols('x')
+    assert fcode(Rational(3, 7)) == "      3.0d0/7.0d0"
+    assert fcode(Rational(18, 9)) == "      2"
+    assert fcode(Rational(3, -7)) == "      -3.0d0/7.0d0"
+    assert fcode(Rational(-3, -7)) == "      3.0d0/7.0d0"
+    assert fcode(x + Rational(3, 7)) == "      x + 3.0d0/7.0d0"
+    assert fcode(Rational(3, 7)*x) == "      (3.0d0/7.0d0)*x"
+
+
+def test_fcode_Integer():
+    assert fcode(Integer(67)) == "      67"
+    assert fcode(Integer(-1)) == "      -1"
+
+
+def test_fcode_Float():
+    assert fcode(Float(42.0)) == "      42.0000000000000d0"
+    assert fcode(Float(-1e20)) == "      -1.00000000000000d+20"
+
+
+def test_fcode_functions():
+    x, y = symbols('x,y')
+    assert fcode(sin(x) ** cos(y)) == "      sin(x)**cos(y)"
+    raises(NotImplementedError, lambda: fcode(Mod(x, y), standard=66))
+    raises(NotImplementedError, lambda: fcode(x % y, standard=66))
+    raises(NotImplementedError, lambda: fcode(Mod(x, y), standard=77))
+    raises(NotImplementedError, lambda: fcode(x % y, standard=77))
+    for standard in [90, 95, 2003, 2008]:
+        assert fcode(Mod(x, y), standard=standard) == "      modulo(x, y)"
+        assert fcode(x % y, standard=standard) == "      modulo(x, y)"
+
+
+def test_case():
+    ob = FCodePrinter()
+    x,x_,x__,y,X,X_,Y = symbols('x,x_,x__,y,X,X_,Y')
+    assert fcode(exp(x_) + sin(x*y) + cos(X*Y)) == \
+                        '      exp(x_) + sin(x*y) + cos(X__*Y_)'
+    assert fcode(exp(x__) + 2*x*Y*X_**Rational(7, 2)) == \
+                        '      2*X_**(7.0d0/2.0d0)*Y*x + exp(x__)'
+    assert fcode(exp(x_) + sin(x*y) + cos(X*Y), name_mangling=False) == \
+                        '      exp(x_) + sin(x*y) + cos(X*Y)'
+    assert fcode(x - cos(X), name_mangling=False) == '      x - cos(X)'
+    assert ob.doprint(X*sin(x) + x_, assign_to='me') == '      me = X*sin(x_) + x__'
+    assert ob.doprint(X*sin(x), assign_to='mu') == '      mu = X*sin(x_)'
+    assert ob.doprint(x_, assign_to='ad') == '      ad = x__'
+    n, m = symbols('n,m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    I = Idx('I', n)
+    assert fcode(A[i, I]*x[I], assign_to=y[i], source_format='free') == (
+                                            "do i = 1, m\n"
+                                            "   y(i) = 0\n"
+                                            "end do\n"
+                                            "do i = 1, m\n"
+                                            "   do I_ = 1, n\n"
+                                            "      y(i) = A(i, I_)*x(I_) + y(i)\n"
+                                            "   end do\n"
+                                            "end do" )
+
+
+#issue 6814
+def test_fcode_functions_with_integers():
+    x= symbols('x')
+    log10_17 = log(10).evalf(17)
+    loglog10_17 = '0.8340324452479558d0'
+    assert fcode(x * log(10)) == "      x*%sd0" % log10_17
+    assert fcode(x * log(10)) == "      x*%sd0" % log10_17
+    assert fcode(x * log(S(10))) == "      x*%sd0" % log10_17
+    assert fcode(log(S(10))) == "      %sd0" % log10_17
+    assert fcode(exp(10)) == "      %sd0" % exp(10).evalf(17)
+    assert fcode(x * log(log(10))) == "      x*%s" % loglog10_17
+    assert fcode(x * log(log(S(10)))) == "      x*%s" % loglog10_17
+
+
+def test_fcode_NumberSymbol():
+    prec = 17
+    p = FCodePrinter()
+    assert fcode(Catalan) == '      parameter (Catalan = %sd0)\n      Catalan' % Catalan.evalf(prec)
+    assert fcode(EulerGamma) == '      parameter (EulerGamma = %sd0)\n      EulerGamma' % EulerGamma.evalf(prec)
+    assert fcode(E) == '      parameter (E = %sd0)\n      E' % E.evalf(prec)
+    assert fcode(GoldenRatio) == '      parameter (GoldenRatio = %sd0)\n      GoldenRatio' % GoldenRatio.evalf(prec)
+    assert fcode(pi) == '      parameter (pi = %sd0)\n      pi' % pi.evalf(prec)
+    assert fcode(
+        pi, precision=5) == '      parameter (pi = %sd0)\n      pi' % pi.evalf(5)
+    assert fcode(Catalan, human=False) == ({
+        (Catalan, p._print(Catalan.evalf(prec)))}, set(), '      Catalan')
+    assert fcode(EulerGamma, human=False) == ({(EulerGamma, p._print(
+        EulerGamma.evalf(prec)))}, set(), '      EulerGamma')
+    assert fcode(E, human=False) == (
+        {(E, p._print(E.evalf(prec)))}, set(), '      E')
+    assert fcode(GoldenRatio, human=False) == ({(GoldenRatio, p._print(
+        GoldenRatio.evalf(prec)))}, set(), '      GoldenRatio')
+    assert fcode(pi, human=False) == (
+        {(pi, p._print(pi.evalf(prec)))}, set(), '      pi')
+    assert fcode(pi, precision=5, human=False) == (
+        {(pi, p._print(pi.evalf(5)))}, set(), '      pi')
+
+
+def test_fcode_complex():
+    assert fcode(I) == "      cmplx(0,1)"
+    x = symbols('x')
+    assert fcode(4*I) == "      cmplx(0,4)"
+    assert fcode(3 + 4*I) == "      cmplx(3,4)"
+    assert fcode(3 + 4*I + x) == "      cmplx(3,4) + x"
+    assert fcode(I*x) == "      cmplx(0,1)*x"
+    assert fcode(3 + 4*I - x) == "      cmplx(3,4) - x"
+    x = symbols('x', imaginary=True)
+    assert fcode(5*x) == "      5*x"
+    assert fcode(I*x) == "      cmplx(0,1)*x"
+    assert fcode(3 + x) == "      x + 3"
+
+
+def test_implicit():
+    x, y = symbols('x,y')
+    assert fcode(sin(x)) == "      sin(x)"
+    assert fcode(atan2(x, y)) == "      atan2(x, y)"
+    assert fcode(conjugate(x)) == "      conjg(x)"
+
+
+def test_not_fortran():
+    x = symbols('x')
+    g = Function('g')
+    gamma_f = fcode(gamma(x))
+    assert gamma_f == "C     Not supported in Fortran:\nC     gamma\n      gamma(x)"
+    assert fcode(Integral(sin(x))) == "C     Not supported in Fortran:\nC     Integral\n      Integral(sin(x), x)"
+    assert fcode(g(x)) == "C     Not supported in Fortran:\nC     g\n      g(x)"
+
+
+def test_user_functions():
+    x = symbols('x')
+    assert fcode(sin(x), user_functions={"sin": "zsin"}) == "      zsin(x)"
+    x = symbols('x')
+    assert fcode(
+        gamma(x), user_functions={"gamma": "mygamma"}) == "      mygamma(x)"
+    g = Function('g')
+    assert fcode(g(x), user_functions={"g": "great"}) == "      great(x)"
+    n = symbols('n', integer=True)
+    assert fcode(
+        factorial(n), user_functions={"factorial": "fct"}) == "      fct(n)"
+
+
+def test_inline_function():
+    x = symbols('x')
+    g = implemented_function('g', Lambda(x, 2*x))
+    assert fcode(g(x)) == "      2*x"
+    g = implemented_function('g', Lambda(x, 2*pi/x))
+    assert fcode(g(x)) == (
+        "      parameter (pi = %sd0)\n"
+        "      2*pi/x"
+    ) % pi.evalf(17)
+    A = IndexedBase('A')
+    i = Idx('i', symbols('n', integer=True))
+    g = implemented_function('g', Lambda(x, x*(1 + x)*(2 + x)))
+    assert fcode(g(A[i]), assign_to=A[i]) == (
+        "      do i = 1, n\n"
+        "         A(i) = (A(i) + 1)*(A(i) + 2)*A(i)\n"
+        "      end do"
+    )
+
+
+def test_assign_to():
+    x = symbols('x')
+    assert fcode(sin(x), assign_to="s") == "      s = sin(x)"
+
+
+def test_line_wrapping():
+    x, y = symbols('x,y')
+    assert fcode(((x + y)**10).expand(), assign_to="var") == (
+        "      var = x**10 + 10*x**9*y + 45*x**8*y**2 + 120*x**7*y**3 + 210*x**6*\n"
+        "     @ y**4 + 252*x**5*y**5 + 210*x**4*y**6 + 120*x**3*y**7 + 45*x**2*y\n"
+        "     @ **8 + 10*x*y**9 + y**10"
+    )
+    e = [x**i for i in range(11)]
+    assert fcode(Add(*e)) == (
+        "      x**10 + x**9 + x**8 + x**7 + x**6 + x**5 + x**4 + x**3 + x**2 + x\n"
+        "     @ + 1"
+    )
+
+
+def test_fcode_precedence():
+    x, y = symbols("x y")
+    assert fcode(And(x < y, y < x + 1), source_format="free") == \
+        "x < y .and. y < x + 1"
+    assert fcode(Or(x < y, y < x + 1), source_format="free") == \
+        "x < y .or. y < x + 1"
+    assert fcode(Xor(x < y, y < x + 1, evaluate=False),
+        source_format="free") == "x < y .neqv. y < x + 1"
+    assert fcode(Equivalent(x < y, y < x + 1), source_format="free") == \
+        "x < y .eqv. y < x + 1"
+
+
+def test_fcode_Logical():
+    x, y, z = symbols("x y z")
+    # unary Not
+    assert fcode(Not(x), source_format="free") == ".not. x"
+    # binary And
+    assert fcode(And(x, y), source_format="free") == "x .and. y"
+    assert fcode(And(x, Not(y)), source_format="free") == "x .and. .not. y"
+    assert fcode(And(Not(x), y), source_format="free") == "y .and. .not. x"
+    assert fcode(And(Not(x), Not(y)), source_format="free") == \
+        ".not. x .and. .not. y"
+    assert fcode(Not(And(x, y), evaluate=False), source_format="free") == \
+        ".not. (x .and. y)"
+    # binary Or
+    assert fcode(Or(x, y), source_format="free") == "x .or. y"
+    assert fcode(Or(x, Not(y)), source_format="free") == "x .or. .not. y"
+    assert fcode(Or(Not(x), y), source_format="free") == "y .or. .not. x"
+    assert fcode(Or(Not(x), Not(y)), source_format="free") == \
+        ".not. x .or. .not. y"
+    assert fcode(Not(Or(x, y), evaluate=False), source_format="free") == \
+        ".not. (x .or. y)"
+    # mixed And/Or
+    assert fcode(And(Or(y, z), x), source_format="free") == "x .and. (y .or. z)"
+    assert fcode(And(Or(z, x), y), source_format="free") == "y .and. (x .or. z)"
+    assert fcode(And(Or(x, y), z), source_format="free") == "z .and. (x .or. y)"
+    assert fcode(Or(And(y, z), x), source_format="free") == "x .or. y .and. z"
+    assert fcode(Or(And(z, x), y), source_format="free") == "y .or. x .and. z"
+    assert fcode(Or(And(x, y), z), source_format="free") == "z .or. x .and. y"
+    # trinary And
+    assert fcode(And(x, y, z), source_format="free") == "x .and. y .and. z"
+    assert fcode(And(x, y, Not(z)), source_format="free") == \
+        "x .and. y .and. .not. z"
+    assert fcode(And(x, Not(y), z), source_format="free") == \
+        "x .and. z .and. .not. y"
+    assert fcode(And(Not(x), y, z), source_format="free") == \
+        "y .and. z .and. .not. x"
+    assert fcode(Not(And(x, y, z), evaluate=False), source_format="free") == \
+        ".not. (x .and. y .and. z)"
+    # trinary Or
+    assert fcode(Or(x, y, z), source_format="free") == "x .or. y .or. z"
+    assert fcode(Or(x, y, Not(z)), source_format="free") == \
+        "x .or. y .or. .not. z"
+    assert fcode(Or(x, Not(y), z), source_format="free") == \
+        "x .or. z .or. .not. y"
+    assert fcode(Or(Not(x), y, z), source_format="free") == \
+        "y .or. z .or. .not. x"
+    assert fcode(Not(Or(x, y, z), evaluate=False), source_format="free") == \
+        ".not. (x .or. y .or. z)"
+
+
+def test_fcode_Xlogical():
+    x, y, z = symbols("x y z")
+    # binary Xor
+    assert fcode(Xor(x, y, evaluate=False), source_format="free") == \
+        "x .neqv. y"
+    assert fcode(Xor(x, Not(y), evaluate=False), source_format="free") == \
+        "x .neqv. .not. y"
+    assert fcode(Xor(Not(x), y, evaluate=False), source_format="free") == \
+        "y .neqv. .not. x"
+    assert fcode(Xor(Not(x), Not(y), evaluate=False),
+        source_format="free") == ".not. x .neqv. .not. y"
+    assert fcode(Not(Xor(x, y, evaluate=False), evaluate=False),
+        source_format="free") == ".not. (x .neqv. y)"
+    # binary Equivalent
+    assert fcode(Equivalent(x, y), source_format="free") == "x .eqv. y"
+    assert fcode(Equivalent(x, Not(y)), source_format="free") == \
+        "x .eqv. .not. y"
+    assert fcode(Equivalent(Not(x), y), source_format="free") == \
+        "y .eqv. .not. x"
+    assert fcode(Equivalent(Not(x), Not(y)), source_format="free") == \
+        ".not. x .eqv. .not. y"
+    assert fcode(Not(Equivalent(x, y), evaluate=False),
+        source_format="free") == ".not. (x .eqv. y)"
+    # mixed And/Equivalent
+    assert fcode(Equivalent(And(y, z), x), source_format="free") == \
+        "x .eqv. y .and. z"
+    assert fcode(Equivalent(And(z, x), y), source_format="free") == \
+        "y .eqv. x .and. z"
+    assert fcode(Equivalent(And(x, y), z), source_format="free") == \
+        "z .eqv. x .and. y"
+    assert fcode(And(Equivalent(y, z), x), source_format="free") == \
+        "x .and. (y .eqv. z)"
+    assert fcode(And(Equivalent(z, x), y), source_format="free") == \
+        "y .and. (x .eqv. z)"
+    assert fcode(And(Equivalent(x, y), z), source_format="free") == \
+        "z .and. (x .eqv. y)"
+    # mixed Or/Equivalent
+    assert fcode(Equivalent(Or(y, z), x), source_format="free") == \
+        "x .eqv. y .or. z"
+    assert fcode(Equivalent(Or(z, x), y), source_format="free") == \
+        "y .eqv. x .or. z"
+    assert fcode(Equivalent(Or(x, y), z), source_format="free") == \
+        "z .eqv. x .or. y"
+    assert fcode(Or(Equivalent(y, z), x), source_format="free") == \
+        "x .or. (y .eqv. z)"
+    assert fcode(Or(Equivalent(z, x), y), source_format="free") == \
+        "y .or. (x .eqv. z)"
+    assert fcode(Or(Equivalent(x, y), z), source_format="free") == \
+        "z .or. (x .eqv. y)"
+    # mixed Xor/Equivalent
+    assert fcode(Equivalent(Xor(y, z, evaluate=False), x),
+        source_format="free") == "x .eqv. (y .neqv. z)"
+    assert fcode(Equivalent(Xor(z, x, evaluate=False), y),
+        source_format="free") == "y .eqv. (x .neqv. z)"
+    assert fcode(Equivalent(Xor(x, y, evaluate=False), z),
+        source_format="free") == "z .eqv. (x .neqv. y)"
+    assert fcode(Xor(Equivalent(y, z), x, evaluate=False),
+        source_format="free") == "x .neqv. (y .eqv. z)"
+    assert fcode(Xor(Equivalent(z, x), y, evaluate=False),
+        source_format="free") == "y .neqv. (x .eqv. z)"
+    assert fcode(Xor(Equivalent(x, y), z, evaluate=False),
+        source_format="free") == "z .neqv. (x .eqv. y)"
+    # mixed And/Xor
+    assert fcode(Xor(And(y, z), x, evaluate=False), source_format="free") == \
+        "x .neqv. y .and. z"
+    assert fcode(Xor(And(z, x), y, evaluate=False), source_format="free") == \
+        "y .neqv. x .and. z"
+    assert fcode(Xor(And(x, y), z, evaluate=False), source_format="free") == \
+        "z .neqv. x .and. y"
+    assert fcode(And(Xor(y, z, evaluate=False), x), source_format="free") == \
+        "x .and. (y .neqv. z)"
+    assert fcode(And(Xor(z, x, evaluate=False), y), source_format="free") == \
+        "y .and. (x .neqv. z)"
+    assert fcode(And(Xor(x, y, evaluate=False), z), source_format="free") == \
+        "z .and. (x .neqv. y)"
+    # mixed Or/Xor
+    assert fcode(Xor(Or(y, z), x, evaluate=False), source_format="free") == \
+        "x .neqv. y .or. z"
+    assert fcode(Xor(Or(z, x), y, evaluate=False), source_format="free") == \
+        "y .neqv. x .or. z"
+    assert fcode(Xor(Or(x, y), z, evaluate=False), source_format="free") == \
+        "z .neqv. x .or. y"
+    assert fcode(Or(Xor(y, z, evaluate=False), x), source_format="free") == \
+        "x .or. (y .neqv. z)"
+    assert fcode(Or(Xor(z, x, evaluate=False), y), source_format="free") == \
+        "y .or. (x .neqv. z)"
+    assert fcode(Or(Xor(x, y, evaluate=False), z), source_format="free") == \
+        "z .or. (x .neqv. y)"
+    # trinary Xor
+    assert fcode(Xor(x, y, z, evaluate=False), source_format="free") == \
+        "x .neqv. y .neqv. z"
+    assert fcode(Xor(x, y, Not(z), evaluate=False), source_format="free") == \
+        "x .neqv. y .neqv. .not. z"
+    assert fcode(Xor(x, Not(y), z, evaluate=False), source_format="free") == \
+        "x .neqv. z .neqv. .not. y"
+    assert fcode(Xor(Not(x), y, z, evaluate=False), source_format="free") == \
+        "y .neqv. z .neqv. .not. x"
+
+
+def test_fcode_Relational():
+    x, y = symbols("x y")
+    assert fcode(Relational(x, y, "=="), source_format="free") == "x == y"
+    assert fcode(Relational(x, y, "!="), source_format="free") == "x /= y"
+    assert fcode(Relational(x, y, ">="), source_format="free") == "x >= y"
+    assert fcode(Relational(x, y, "<="), source_format="free") == "x <= y"
+    assert fcode(Relational(x, y, ">"), source_format="free") == "x > y"
+    assert fcode(Relational(x, y, "<"), source_format="free") == "x < y"
+
+
+def test_fcode_Piecewise():
+    x = symbols('x')
+    expr = Piecewise((x, x < 1), (x**2, True))
+    # Check that inline conditional (merge) fails if standard isn't 95+
+    raises(NotImplementedError, lambda: fcode(expr))
+    code = fcode(expr, standard=95)
+    expected = "      merge(x, x**2, x < 1)"
+    assert code == expected
+    assert fcode(Piecewise((x, x < 1), (x**2, True)), assign_to="var") == (
+        "      if (x < 1) then\n"
+        "         var = x\n"
+        "      else\n"
+        "         var = x**2\n"
+        "      end if"
+    )
+    a = cos(x)/x
+    b = sin(x)/x
+    for i in range(10):
+        a = diff(a, x)
+        b = diff(b, x)
+    expected = (
+        "      if (x < 0) then\n"
+        "         weird_name = -cos(x)/x + 10*sin(x)/x**2 + 90*cos(x)/x**3 - 720*\n"
+        "     @ sin(x)/x**4 - 5040*cos(x)/x**5 + 30240*sin(x)/x**6 + 151200*cos(x\n"
+        "     @ )/x**7 - 604800*sin(x)/x**8 - 1814400*cos(x)/x**9 + 3628800*sin(x\n"
+        "     @ )/x**10 + 3628800*cos(x)/x**11\n"
+        "      else\n"
+        "         weird_name = -sin(x)/x - 10*cos(x)/x**2 + 90*sin(x)/x**3 + 720*\n"
+        "     @ cos(x)/x**4 - 5040*sin(x)/x**5 - 30240*cos(x)/x**6 + 151200*sin(x\n"
+        "     @ )/x**7 + 604800*cos(x)/x**8 - 1814400*sin(x)/x**9 - 3628800*cos(x\n"
+        "     @ )/x**10 + 3628800*sin(x)/x**11\n"
+        "      end if"
+    )
+    code = fcode(Piecewise((a, x < 0), (b, True)), assign_to="weird_name")
+    assert code == expected
+    code = fcode(Piecewise((x, x < 1), (x**2, x > 1), (sin(x), True)), standard=95)
+    expected = "      merge(x, merge(x**2, sin(x), x > 1), x < 1)"
+    assert code == expected
+    # Check that Piecewise without a True (default) condition error
+    expr = Piecewise((x, x < 1), (x**2, x > 1), (sin(x), x > 0))
+    raises(ValueError, lambda: fcode(expr))
+
+
+def test_wrap_fortran():
+    #   "########################################################################"
+    printer = FCodePrinter()
+    lines = [
+        "C     This is a long comment on a single line that must be wrapped properly to produce nice output",
+        "      this = is + a + long + and + nasty + fortran + statement + that * must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +  that * must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +   that * must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement + that*must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +   that*must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +    that*must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +     that*must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement + that**must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +  that**must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +   that**must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +    that**must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +     that**must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement(that)/must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran +     statement(that)/must + be + wrapped + properly",
+    ]
+    wrapped_lines = printer._wrap_fortran(lines)
+    expected_lines = [
+        "C     This is a long comment on a single line that must be wrapped",
+        "C     properly to produce nice output",
+        "      this = is + a + long + and + nasty + fortran + statement + that *",
+        "     @ must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +  that *",
+        "     @ must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +   that",
+        "     @ * must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement + that*",
+        "     @ must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +   that*",
+        "     @ must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +    that",
+        "     @ *must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +",
+        "     @ that*must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement + that**",
+        "     @ must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +  that**",
+        "     @ must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +   that",
+        "     @ **must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +    that",
+        "     @ **must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement +",
+        "     @ that**must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran + statement(that)/",
+        "     @ must + be + wrapped + properly",
+        "      this = is + a + long + and + nasty + fortran +     statement(that)",
+        "     @ /must + be + wrapped + properly",
+    ]
+    for line in wrapped_lines:
+        assert len(line) <= 72
+    for w, e in zip(wrapped_lines, expected_lines):
+        assert w == e
+    assert len(wrapped_lines) == len(expected_lines)
+
+
+def test_wrap_fortran_keep_d0():
+    printer = FCodePrinter()
+    lines = [
+        '      this_variable_is_very_long_because_we_try_to_test_line_break=1.0d0',
+        '      this_variable_is_very_long_because_we_try_to_test_line_break =1.0d0',
+        '      this_variable_is_very_long_because_we_try_to_test_line_break  = 1.0d0',
+        '      this_variable_is_very_long_because_we_try_to_test_line_break   = 1.0d0',
+        '      this_variable_is_very_long_because_we_try_to_test_line_break    = 1.0d0',
+        '      this_variable_is_very_long_because_we_try_to_test_line_break = 10.0d0'
+    ]
+    expected = [
+        '      this_variable_is_very_long_because_we_try_to_test_line_break=1.0d0',
+        '      this_variable_is_very_long_because_we_try_to_test_line_break =',
+        '     @ 1.0d0',
+        '      this_variable_is_very_long_because_we_try_to_test_line_break  =',
+        '     @ 1.0d0',
+        '      this_variable_is_very_long_because_we_try_to_test_line_break   =',
+        '     @ 1.0d0',
+        '      this_variable_is_very_long_because_we_try_to_test_line_break    =',
+        '     @ 1.0d0',
+        '      this_variable_is_very_long_because_we_try_to_test_line_break =',
+        '     @ 10.0d0'
+    ]
+    assert printer._wrap_fortran(lines) == expected
+
+
+def test_settings():
+    raises(TypeError, lambda: fcode(S(4), method="garbage"))
+
+
+def test_free_form_code_line():
+    x, y = symbols('x,y')
+    assert fcode(cos(x) + sin(y), source_format='free') == "sin(y) + cos(x)"
+
+
+def test_free_form_continuation_line():
+    x, y = symbols('x,y')
+    result = fcode(((cos(x) + sin(y))**(7)).expand(), source_format='free')
+    expected = (
+        'sin(y)**7 + 7*sin(y)**6*cos(x) + 21*sin(y)**5*cos(x)**2 + 35*sin(y)**4* &\n'
+        '      cos(x)**3 + 35*sin(y)**3*cos(x)**4 + 21*sin(y)**2*cos(x)**5 + 7* &\n'
+        '      sin(y)*cos(x)**6 + cos(x)**7'
+    )
+    assert result == expected
+
+
+def test_free_form_comment_line():
+    printer = FCodePrinter({'source_format': 'free'})
+    lines = [ "! This is a long comment on a single line that must be wrapped properly to produce nice output"]
+    expected = [
+        '! This is a long comment on a single line that must be wrapped properly',
+        '! to produce nice output']
+    assert printer._wrap_fortran(lines) == expected
+
+
+def test_loops():
+    n, m = symbols('n,m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+
+    expected = (
+        'do i = 1, m\n'
+        '   y(i) = 0\n'
+        'end do\n'
+        'do i = 1, m\n'
+        '   do j = 1, n\n'
+        '      y(i) = %(rhs)s\n'
+        '   end do\n'
+        'end do'
+    )
+
+    code = fcode(A[i, j]*x[j], assign_to=y[i], source_format='free')
+    assert (code == expected % {'rhs': 'y(i) + A(i, j)*x(j)'} or
+            code == expected % {'rhs': 'y(i) + x(j)*A(i, j)'} or
+            code == expected % {'rhs': 'x(j)*A(i, j) + y(i)'} or
+            code == expected % {'rhs': 'A(i, j)*x(j) + y(i)'})
+
+
+def test_dummy_loops():
+    i, m = symbols('i m', integer=True, cls=Dummy)
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx(i, m)
+
+    expected = (
+        'do i_%(icount)i = 1, m_%(mcount)i\n'
+        '   y(i_%(icount)i) = x(i_%(icount)i)\n'
+        'end do'
+    ) % {'icount': i.label.dummy_index, 'mcount': m.dummy_index}
+    code = fcode(x[i], assign_to=y[i], source_format='free')
+    assert code == expected
+
+
+def test_fcode_Indexed_without_looking_for_contraction():
+    len_y = 5
+    y = IndexedBase('y', shape=(len_y,))
+    x = IndexedBase('x', 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])/(x[i+1]-x[i]))
+    code0 = fcode(e.rhs, assign_to=e.lhs, contract=False)
+    assert code0.endswith('Dy(i) = (y(i + 1) - y(i))/(x(i + 1) - x(i))')
+
+
+def test_element_like_objects():
+    len_y = 5
+    y = ArraySymbol('y', shape=(len_y,))
+    x = ArraySymbol('x', shape=(len_y,))
+    Dy = ArraySymbol('Dy', shape=(len_y-1,))
+    i = Idx('i', len_y-1)
+    e=Eq(Dy[i], (y[i+1]-y[i])/(x[i+1]-x[i]))
+    code0 = fcode(Assignment(e.lhs, e.rhs))
+    assert code0.endswith('Dy(i) = (y(i + 1) - y(i))/(x(i + 1) - x(i))')
+
+    class ElementExpr(Element, Expr):
+        pass
+
+    e = e.subs((a, ElementExpr(a.name, a.indices)) for a in e.atoms(ArrayElement)  )
+    e=Eq(Dy[i], (y[i+1]-y[i])/(x[i+1]-x[i]))
+    code0 = fcode(Assignment(e.lhs, e.rhs))
+    assert code0.endswith('Dy(i) = (y(i + 1) - y(i))/(x(i + 1) - x(i))')
+
+
+def test_derived_classes():
+    class MyFancyFCodePrinter(FCodePrinter):
+        _default_settings = FCodePrinter._default_settings.copy()
+
+    printer = MyFancyFCodePrinter()
+    x = symbols('x')
+    assert printer.doprint(sin(x), "bork") == "      bork = sin(x)"
+
+
+def test_indent():
+    codelines = (
+        'subroutine test(a)\n'
+        'integer :: a, i, j\n'
+        '\n'
+        'do\n'
+        'do \n'
+        'do j = 1, 5\n'
+        'if (a>b) then\n'
+        'if(b>0) then\n'
+        'a = 3\n'
+        'donot_indent_me = 2\n'
+        'do_not_indent_me_either = 2\n'
+        'ifIam_indented_something_went_wrong = 2\n'
+        'if_I_am_indented_something_went_wrong = 2\n'
+        'end should not be unindented here\n'
+        'end if\n'
+        'endif\n'
+        'end do\n'
+        'end do\n'
+        'enddo\n'
+        'end subroutine\n'
+        '\n'
+        'subroutine test2(a)\n'
+        'integer :: a\n'
+        'do\n'
+        'a = a + 1\n'
+        'end do \n'
+        'end subroutine\n'
+    )
+    expected = (
+        'subroutine test(a)\n'
+        'integer :: a, i, j\n'
+        '\n'
+        'do\n'
+        '   do \n'
+        '      do j = 1, 5\n'
+        '         if (a>b) then\n'
+        '            if(b>0) then\n'
+        '               a = 3\n'
+        '               donot_indent_me = 2\n'
+        '               do_not_indent_me_either = 2\n'
+        '               ifIam_indented_something_went_wrong = 2\n'
+        '               if_I_am_indented_something_went_wrong = 2\n'
+        '               end should not be unindented here\n'
+        '            end if\n'
+        '         endif\n'
+        '      end do\n'
+        '   end do\n'
+        'enddo\n'
+        'end subroutine\n'
+        '\n'
+        'subroutine test2(a)\n'
+        'integer :: a\n'
+        'do\n'
+        '   a = a + 1\n'
+        'end do \n'
+        'end subroutine\n'
+    )
+    p = FCodePrinter({'source_format': 'free'})
+    result = p.indent_code(codelines)
+    assert result == expected
+
+def test_Matrix_printing():
+    x, y, z = symbols('x,y,z')
+    # Test returning a Matrix
+    mat = Matrix([x*y, Piecewise((2 + x, y>0), (y, True)), sin(z)])
+    A = MatrixSymbol('A', 3, 1)
+    assert fcode(mat, A) == (
+        "      A(1, 1) = x*y\n"
+        "      if (y > 0) then\n"
+        "         A(2, 1) = x + 2\n"
+        "      else\n"
+        "         A(2, 1) = y\n"
+        "      end if\n"
+        "      A(3, 1) = sin(z)")
+    # Test using MatrixElements in expressions
+    expr = Piecewise((2*A[2, 0], x > 0), (A[2, 0], True)) + sin(A[1, 0]) + A[0, 0]
+    assert fcode(expr, standard=95) == (
+        "      merge(2*A(3, 1), A(3, 1), x > 0) + sin(A(2, 1)) + A(1, 1)")
+    # Test using MatrixElements in a Matrix
+    q = MatrixSymbol('q', 5, 1)
+    M = MatrixSymbol('M', 3, 3)
+    m = Matrix([[sin(q[1,0]), 0, cos(q[2,0])],
+        [q[1,0] + q[2,0], q[3, 0], 5],
+        [2*q[4, 0]/q[1,0], sqrt(q[0,0]) + 4, 0]])
+    assert fcode(m, M) == (
+        "      M(1, 1) = sin(q(2, 1))\n"
+        "      M(2, 1) = q(2, 1) + q(3, 1)\n"
+        "      M(3, 1) = 2*q(5, 1)/q(2, 1)\n"
+        "      M(1, 2) = 0\n"
+        "      M(2, 2) = q(4, 1)\n"
+        "      M(3, 2) = sqrt(q(1, 1)) + 4\n"
+        "      M(1, 3) = cos(q(3, 1))\n"
+        "      M(2, 3) = 5\n"
+        "      M(3, 3) = 0")
+
+
+def test_fcode_For():
+    x, y = symbols('x y')
+
+    f = For(x, Range(0, 10, 2), [Assignment(y, x * y)])
+    sol = fcode(f)
+    assert sol == ("      do x = 0, 9, 2\n"
+                   "         y = x*y\n"
+                   "      end do")
+
+
+def test_fcode_Declaration():
+    def check(expr, ref, **kwargs):
+        assert fcode(expr, standard=95, source_format='free', **kwargs) == ref
+
+    i = symbols('i', integer=True)
+    var1 = Variable.deduced(i)
+    dcl1 = Declaration(var1)
+    check(dcl1, "integer*4 :: i")
+
+
+    x, y = symbols('x y')
+    var2 = Variable(x, float32, value=42, attrs={value_const})
+    dcl2b = Declaration(var2)
+    check(dcl2b, 'real*4, parameter :: x = 42')
+
+    var3 = Variable(y, type=bool_)
+    dcl3 = Declaration(var3)
+    check(dcl3, 'logical :: y')
+
+    check(float32, "real*4")
+    check(float64, "real*8")
+    check(real, "real*4", type_aliases={real: float32})
+    check(real, "real*8", type_aliases={real: float64})
+
+
+def test_MatrixElement_printing():
+    # test cases for issue #11821
+    A = MatrixSymbol("A", 1, 3)
+    B = MatrixSymbol("B", 1, 3)
+    C = MatrixSymbol("C", 1, 3)
+
+    assert(fcode(A[0, 0]) == "      A(1, 1)")
+    assert(fcode(3 * A[0, 0]) == "      3*A(1, 1)")
+
+    F = C[0, 0].subs(C, A - B)
+    assert(fcode(F) == "      (A - B)(1, 1)")
+
+
+def test_aug_assign():
+    x = symbols('x')
+    assert fcode(aug_assign(x, '+', 1), source_format='free') == 'x = x + 1'
+
+
+def test_While():
+    x = symbols('x')
+    assert fcode(While(abs(x) > 1, [aug_assign(x, '-', 1)]), source_format='free') == (
+        'do while (abs(x) > 1)\n'
+        '   x = x - 1\n'
+        'end do'
+    )
+
+
+def test_FunctionPrototype_print():
+    x = symbols('x')
+    n = symbols('n', integer=True)
+    vx = Variable(x, type=real)
+    vn = Variable(n, type=integer)
+    fp1 = FunctionPrototype(real, 'power', [vx, vn])
+    # Should be changed to proper test once multi-line generation is working
+    # see https://github.com/sympy/sympy/issues/15824
+    raises(NotImplementedError, lambda: fcode(fp1))
+
+
+def test_FunctionDefinition_print():
+    x = symbols('x')
+    n = symbols('n', integer=True)
+    vx = Variable(x, type=real)
+    vn = Variable(n, type=integer)
+    body = [Assignment(x, x**n), Return(x)]
+    fd1 = FunctionDefinition(real, 'power', [vx, vn], body)
+    # Should be changed to proper test once multi-line generation is working
+    # see https://github.com/sympy/sympy/issues/15824
+    raises(NotImplementedError, lambda: fcode(fd1))

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_glsl.py

@@ -0,0 +1,998 @@
+from sympy.core import (pi, symbols, Rational, Integer, GoldenRatio, EulerGamma,
+                        Catalan, Lambda, Dummy, Eq, Ne, Le, Lt, Gt, Ge)
+from sympy.functions import Piecewise, sin, cos, Abs, exp, ceiling, sqrt
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+from sympy.printing.glsl import GLSLPrinter
+from sympy.printing.str import StrPrinter
+from sympy.utilities.lambdify import implemented_function
+from sympy.tensor import IndexedBase, Idx
+from sympy.matrices import Matrix, MatrixSymbol
+from sympy.core import Tuple
+from sympy.printing.glsl import glsl_code
+import textwrap
+
+x, y, z = symbols('x,y,z')
+
+
+def test_printmethod():
+    assert glsl_code(Abs(x)) == "abs(x)"
+
+def test_print_without_operators():
+    assert glsl_code(x*y,use_operators = False) == 'mul(x, y)'
+    assert glsl_code(x**y+z,use_operators = False) == 'add(pow(x, y), z)'
+    assert glsl_code(x*(y+z),use_operators = False) == 'mul(x, add(y, z))'
+    assert glsl_code(x*(y+z),use_operators = False) == 'mul(x, add(y, z))'
+    assert glsl_code(x*(y+z**y**0.5),use_operators = False) == 'mul(x, add(y, pow(z, sqrt(y))))'
+    assert glsl_code(-x-y, use_operators=False, zero='zero()') == 'sub(zero(), add(x, y))'
+    assert glsl_code(-x-y, use_operators=False) == 'sub(0.0, add(x, y))'
+
+def test_glsl_code_sqrt():
+    assert glsl_code(sqrt(x)) == "sqrt(x)"
+    assert glsl_code(x**0.5) == "sqrt(x)"
+    assert glsl_code(sqrt(x)) == "sqrt(x)"
+
+
+def test_glsl_code_Pow():
+    g = implemented_function('g', Lambda(x, 2*x))
+    assert glsl_code(x**3) == "pow(x, 3.0)"
+    assert glsl_code(x**(y**3)) == "pow(x, pow(y, 3.0))"
+    assert glsl_code(1/(g(x)*3.5)**(x - y**x)/(x**2 + y)) == \
+        "pow(3.5*2*x, -x + pow(y, x))/(pow(x, 2.0) + y)"
+    assert glsl_code(x**-1.0) == '1.0/x'
+
+
+def test_glsl_code_Relational():
+    assert glsl_code(Eq(x, y)) == "x == y"
+    assert glsl_code(Ne(x, y)) == "x != y"
+    assert glsl_code(Le(x, y)) == "x <= y"
+    assert glsl_code(Lt(x, y)) == "x < y"
+    assert glsl_code(Gt(x, y)) == "x > y"
+    assert glsl_code(Ge(x, y)) == "x >= y"
+
+
+def test_glsl_code_constants_mathh():
+    assert glsl_code(exp(1)) == "float E = 2.71828183;\nE"
+    assert glsl_code(pi) == "float pi = 3.14159265;\npi"
+    # assert glsl_code(oo) == "Number.POSITIVE_INFINITY"
+    # assert glsl_code(-oo) == "Number.NEGATIVE_INFINITY"
+
+
+def test_glsl_code_constants_other():
+    assert glsl_code(2*GoldenRatio) == "float GoldenRatio = 1.61803399;\n2*GoldenRatio"
+    assert glsl_code(2*Catalan) == "float Catalan = 0.915965594;\n2*Catalan"
+    assert glsl_code(2*EulerGamma) == "float EulerGamma = 0.577215665;\n2*EulerGamma"
+
+
+def test_glsl_code_Rational():
+    assert glsl_code(Rational(3, 7)) == "3.0/7.0"
+    assert glsl_code(Rational(18, 9)) == "2"
+    assert glsl_code(Rational(3, -7)) == "-3.0/7.0"
+    assert glsl_code(Rational(-3, -7)) == "3.0/7.0"
+
+
+def test_glsl_code_Integer():
+    assert glsl_code(Integer(67)) == "67"
+    assert glsl_code(Integer(-1)) == "-1"
+
+
+def test_glsl_code_functions():
+    assert glsl_code(sin(x) ** cos(x)) == "pow(sin(x), cos(x))"
+
+
+def test_glsl_code_inline_function():
+    x = symbols('x')
+    g = implemented_function('g', Lambda(x, 2*x))
+    assert glsl_code(g(x)) == "2*x"
+    g = implemented_function('g', Lambda(x, 2*x/Catalan))
+    assert glsl_code(g(x)) == "float Catalan = 0.915965594;\n2*x/Catalan"
+    A = IndexedBase('A')
+    i = Idx('i', symbols('n', integer=True))
+    g = implemented_function('g', Lambda(x, x*(1 + x)*(2 + x)))
+    assert glsl_code(g(A[i]), assign_to=A[i]) == (
+        "for (int i=0; i<n; i++){\n"
+        "   A[i] = (A[i] + 1)*(A[i] + 2)*A[i];\n"
+        "}"
+    )
+
+
+def test_glsl_code_exceptions():
+    assert glsl_code(ceiling(x)) == "ceil(x)"
+    assert glsl_code(Abs(x)) == "abs(x)"
+
+
+def test_glsl_code_boolean():
+    assert glsl_code(x & y) == "x && y"
+    assert glsl_code(x | y) == "x || y"
+    assert glsl_code(~x) == "!x"
+    assert glsl_code(x & y & z) == "x && y && z"
+    assert glsl_code(x | y | z) == "x || y || z"
+    assert glsl_code((x & y) | z) == "z || x && y"
+    assert glsl_code((x | y) & z) == "z && (x || y)"
+
+
+def test_glsl_code_Piecewise():
+    expr = Piecewise((x, x < 1), (x**2, True))
+    p = glsl_code(expr)
+    s = \
+"""\
+((x < 1) ? (
+   x
+)
+: (
+   pow(x, 2.0)
+))\
+"""
+    assert p == s
+    assert glsl_code(expr, assign_to="c") == (
+    "if (x < 1) {\n"
+    "   c = x;\n"
+    "}\n"
+    "else {\n"
+    "   c = pow(x, 2.0);\n"
+    "}")
+    # Check that Piecewise without a True (default) condition error
+    expr = Piecewise((x, x < 1), (x**2, x > 1), (sin(x), x > 0))
+    raises(ValueError, lambda: glsl_code(expr))
+
+
+def test_glsl_code_Piecewise_deep():
+    p = glsl_code(2*Piecewise((x, x < 1), (x**2, True)))
+    s = \
+"""\
+2*((x < 1) ? (
+   x
+)
+: (
+   pow(x, 2.0)
+))\
+"""
+    assert p == s
+
+
+def test_glsl_code_settings():
+    raises(TypeError, lambda: glsl_code(sin(x), method="garbage"))
+
+
+def test_glsl_code_Indexed():
+    n, m, o = symbols('n m o', integer=True)
+    i, j, k = Idx('i', n), Idx('j', m), Idx('k', o)
+    p = GLSLPrinter()
+    p._not_c = set()
+
+    x = IndexedBase('x')[j]
+    assert p._print_Indexed(x) == 'x[j]'
+    A = IndexedBase('A')[i, j]
+    assert p._print_Indexed(A) == 'A[%s]' % (m*i+j)
+    B = IndexedBase('B')[i, j, k]
+    assert p._print_Indexed(B) == 'B[%s]' % (i*o*m+j*o+k)
+
+    assert p._not_c == set()
+
+def test_glsl_code_list_tuple_Tuple():
+    assert glsl_code([1,2,3,4]) == 'vec4(1, 2, 3, 4)'
+    assert glsl_code([1,2,3],glsl_types=False) == 'float[3](1, 2, 3)'
+    assert glsl_code([1,2,3]) == glsl_code((1,2,3))
+    assert glsl_code([1,2,3]) == glsl_code(Tuple(1,2,3))
+
+    m = MatrixSymbol('A',3,4)
+    assert glsl_code([m[0],m[1]])
+
+def test_glsl_code_loops_matrix_vector():
+    n, m = symbols('n m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+
+    s = (
+        'for (int i=0; i<m; i++){\n'
+        '   y[i] = 0.0;\n'
+        '}\n'
+        'for (int i=0; i<m; i++){\n'
+        '   for (int j=0; j<n; j++){\n'
+        '      y[i] = A[n*i + j]*x[j] + y[i];\n'
+        '   }\n'
+        '}'
+    )
+
+    c = glsl_code(A[i, j]*x[j], assign_to=y[i])
+    assert c == s
+
+
+def test_dummy_loops():
+    i, m = symbols('i m', integer=True, cls=Dummy)
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx(i, m)
+
+    expected = (
+        'for (int i_%(icount)i=0; i_%(icount)i<m_%(mcount)i; i_%(icount)i++){\n'
+        '   y[i_%(icount)i] = x[i_%(icount)i];\n'
+        '}'
+    ) % {'icount': i.label.dummy_index, 'mcount': m.dummy_index}
+    code = glsl_code(x[i], assign_to=y[i])
+    assert code == expected
+
+
+def test_glsl_code_loops_add():
+    n, m = symbols('n m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    z = IndexedBase('z')
+    i = Idx('i', m)
+    j = Idx('j', n)
+
+    s = (
+        'for (int i=0; i<m; i++){\n'
+        '   y[i] = x[i] + z[i];\n'
+        '}\n'
+        'for (int i=0; i<m; i++){\n'
+        '   for (int j=0; j<n; j++){\n'
+        '      y[i] = A[n*i + j]*x[j] + y[i];\n'
+        '   }\n'
+        '}'
+    )
+    c = glsl_code(A[i, j]*x[j] + x[i] + z[i], assign_to=y[i])
+    assert c == s
+
+
+def test_glsl_code_loops_multiple_contractions():
+    n, m, o, p = symbols('n m o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+    l = Idx('l', p)
+
+    s = (
+        'for (int i=0; i<m; i++){\n'
+        '   y[i] = 0.0;\n'
+        '}\n'
+        'for (int i=0; i<m; i++){\n'
+        '   for (int j=0; j<n; j++){\n'
+        '      for (int k=0; k<o; k++){\n'
+        '         for (int l=0; l<p; l++){\n'
+        '            y[i] = a[%s]*b[%s] + y[i];\n' % (i*n*o*p + j*o*p + k*p + l, j*o*p + k*p + l) +\
+        '         }\n'
+        '      }\n'
+        '   }\n'
+        '}'
+    )
+    c = glsl_code(b[j, k, l]*a[i, j, k, l], assign_to=y[i])
+    assert c == s
+
+
+def test_glsl_code_loops_addfactor():
+    n, m, o, p = symbols('n m o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    c = IndexedBase('c')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+    l = Idx('l', p)
+
+    s = (
+        'for (int i=0; i<m; i++){\n'
+        '   y[i] = 0.0;\n'
+        '}\n'
+        'for (int i=0; i<m; i++){\n'
+        '   for (int j=0; j<n; j++){\n'
+        '      for (int k=0; k<o; k++){\n'
+        '         for (int l=0; l<p; l++){\n'
+        '            y[i] = (a[%s] + b[%s])*c[%s] + y[i];\n' % (i*n*o*p + j*o*p + k*p + l, i*n*o*p + j*o*p + k*p + l, j*o*p + k*p + l) +\
+        '         }\n'
+        '      }\n'
+        '   }\n'
+        '}'
+    )
+    c = glsl_code((a[i, j, k, l] + b[i, j, k, l])*c[j, k, l], assign_to=y[i])
+    assert c == s
+
+
+def test_glsl_code_loops_multiple_terms():
+    n, m, o, p = symbols('n m o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    c = IndexedBase('c')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+
+    s0 = (
+        'for (int i=0; i<m; i++){\n'
+        '   y[i] = 0.0;\n'
+        '}\n'
+    )
+    s1 = (
+        'for (int i=0; i<m; i++){\n'
+        '   for (int j=0; j<n; j++){\n'
+        '      for (int k=0; k<o; k++){\n'
+        '         y[i] = b[j]*b[k]*c[%s] + y[i];\n' % (i*n*o + j*o + k) +\
+        '      }\n'
+        '   }\n'
+        '}\n'
+    )
+    s2 = (
+        'for (int i=0; i<m; i++){\n'
+        '   for (int k=0; k<o; k++){\n'
+        '      y[i] = a[%s]*b[k] + y[i];\n' % (i*o + k) +\
+        '   }\n'
+        '}\n'
+    )
+    s3 = (
+        'for (int i=0; i<m; i++){\n'
+        '   for (int j=0; j<n; j++){\n'
+        '      y[i] = a[%s]*b[j] + y[i];\n' % (i*n + j) +\
+        '   }\n'
+        '}\n'
+    )
+    c = glsl_code(
+        b[j]*a[i, j] + b[k]*a[i, k] + b[j]*b[k]*c[i, j, k], assign_to=y[i])
+    assert (c == s0 + s1 + s2 + s3[:-1] or
+            c == s0 + s1 + s3 + s2[:-1] or
+            c == s0 + s2 + s1 + s3[:-1] or
+            c == s0 + s2 + s3 + s1[:-1] or
+            c == s0 + s3 + s1 + s2[:-1] or
+            c == s0 + s3 + s2 + s1[:-1])
+
+
+def test_Matrix_printing():
+    # Test returning a Matrix
+
+    mat = Matrix([x*y, Piecewise((2 + x, y>0), (y, True)), sin(z)])
+    A = MatrixSymbol('A', 3, 1)
+    assert glsl_code(mat, assign_to=A) == (
+'''A[0][0] = x*y;
+if (y > 0) {
+   A[1][0] = x + 2;
+}
+else {
+   A[1][0] = y;
+}
+A[2][0] = sin(z);''' )
+    assert glsl_code(Matrix([A[0],A[1]]))
+    # Test using MatrixElements in expressions
+    expr = Piecewise((2*A[2, 0], x > 0), (A[2, 0], True)) + sin(A[1, 0]) + A[0, 0]
+    assert glsl_code(expr) == (
+'''((x > 0) ? (
+   2*A[2][0]
+)
+: (
+   A[2][0]
+)) + sin(A[1][0]) + A[0][0]''' )
+
+    # Test using MatrixElements in a Matrix
+    q = MatrixSymbol('q', 5, 1)
+    M = MatrixSymbol('M', 3, 3)
+    m = Matrix([[sin(q[1,0]), 0, cos(q[2,0])],
+        [q[1,0] + q[2,0], q[3, 0], 5],
+        [2*q[4, 0]/q[1,0], sqrt(q[0,0]) + 4, 0]])
+    assert glsl_code(m,M) == (
+'''M[0][0] = sin(q[1]);
+M[0][1] = 0;
+M[0][2] = cos(q[2]);
+M[1][0] = q[1] + q[2];
+M[1][1] = q[3];
+M[1][2] = 5;
+M[2][0] = 2*q[4]/q[1];
+M[2][1] = sqrt(q[0]) + 4;
+M[2][2] = 0;'''
+        )
+
+def test_Matrices_1x7():
+    gl = glsl_code
+    A = Matrix([1,2,3,4,5,6,7])
+    assert gl(A) == 'float[7](1, 2, 3, 4, 5, 6, 7)'
+    assert gl(A.transpose()) == 'float[7](1, 2, 3, 4, 5, 6, 7)'
+
+def test_Matrices_1x7_array_type_int():
+    gl = glsl_code
+    A = Matrix([1,2,3,4,5,6,7])
+    assert gl(A, array_type='int') == 'int[7](1, 2, 3, 4, 5, 6, 7)'
+
+def test_Tuple_array_type_custom():
+    gl = glsl_code
+    A = symbols('a b c')
+    assert gl(A, array_type='AbcType', glsl_types=False) == 'AbcType[3](a, b, c)'
+
+def test_Matrices_1x7_spread_assign_to_symbols():
+    gl = glsl_code
+    A = Matrix([1,2,3,4,5,6,7])
+    assign_to = symbols('x.a x.b x.c x.d x.e x.f x.g')
+    assert gl(A, assign_to=assign_to) == textwrap.dedent('''\
+        x.a = 1;
+        x.b = 2;
+        x.c = 3;
+        x.d = 4;
+        x.e = 5;
+        x.f = 6;
+        x.g = 7;'''
+    )
+
+def test_spread_assign_to_nested_symbols():
+    gl = glsl_code
+    expr = ((1,2,3), (1,2,3))
+    assign_to = (symbols('a b c'), symbols('x y z'))
+    assert gl(expr, assign_to=assign_to) == textwrap.dedent('''\
+        a = 1;
+        b = 2;
+        c = 3;
+        x = 1;
+        y = 2;
+        z = 3;'''
+    )
+
+def test_spread_assign_to_deeply_nested_symbols():
+    gl = glsl_code
+    a, b, c, x, y, z = symbols('a b c x y z')
+    expr = (((1,2),3), ((1,2),3))
+    assign_to = (((a, b), c), ((x, y), z))
+    assert gl(expr, assign_to=assign_to) == textwrap.dedent('''\
+        a = 1;
+        b = 2;
+        c = 3;
+        x = 1;
+        y = 2;
+        z = 3;'''
+    )
+
+def test_matrix_of_tuples_spread_assign_to_symbols():
+    gl = glsl_code
+    with warns_deprecated_sympy():
+        expr = Matrix([[(1,2),(3,4)],[(5,6),(7,8)]])
+    assign_to = (symbols('a b'), symbols('c d'), symbols('e f'), symbols('g h'))
+    assert gl(expr, assign_to) == textwrap.dedent('''\
+        a = 1;
+        b = 2;
+        c = 3;
+        d = 4;
+        e = 5;
+        f = 6;
+        g = 7;
+        h = 8;'''
+    )
+
+def test_cannot_assign_to_cause_mismatched_length():
+    expr = (1, 2)
+    assign_to = symbols('x y z')
+    raises(ValueError, lambda: glsl_code(expr, assign_to))
+
+def test_matrix_4x4_assign():
+    gl = glsl_code
+    expr = MatrixSymbol('A',4,4) * MatrixSymbol('B',4,4) + MatrixSymbol('C',4,4)
+    assign_to = MatrixSymbol('X',4,4)
+    assert gl(expr, assign_to=assign_to) == textwrap.dedent('''\
+        X[0][0] = A[0][0]*B[0][0] + A[0][1]*B[1][0] + A[0][2]*B[2][0] + A[0][3]*B[3][0] + C[0][0];
+        X[0][1] = A[0][0]*B[0][1] + A[0][1]*B[1][1] + A[0][2]*B[2][1] + A[0][3]*B[3][1] + C[0][1];
+        X[0][2] = A[0][0]*B[0][2] + A[0][1]*B[1][2] + A[0][2]*B[2][2] + A[0][3]*B[3][2] + C[0][2];
+        X[0][3] = A[0][0]*B[0][3] + A[0][1]*B[1][3] + A[0][2]*B[2][3] + A[0][3]*B[3][3] + C[0][3];
+        X[1][0] = A[1][0]*B[0][0] + A[1][1]*B[1][0] + A[1][2]*B[2][0] + A[1][3]*B[3][0] + C[1][0];
+        X[1][1] = A[1][0]*B[0][1] + A[1][1]*B[1][1] + A[1][2]*B[2][1] + A[1][3]*B[3][1] + C[1][1];
+        X[1][2] = A[1][0]*B[0][2] + A[1][1]*B[1][2] + A[1][2]*B[2][2] + A[1][3]*B[3][2] + C[1][2];
+        X[1][3] = A[1][0]*B[0][3] + A[1][1]*B[1][3] + A[1][2]*B[2][3] + A[1][3]*B[3][3] + C[1][3];
+        X[2][0] = A[2][0]*B[0][0] + A[2][1]*B[1][0] + A[2][2]*B[2][0] + A[2][3]*B[3][0] + C[2][0];
+        X[2][1] = A[2][0]*B[0][1] + A[2][1]*B[1][1] + A[2][2]*B[2][1] + A[2][3]*B[3][1] + C[2][1];
+        X[2][2] = A[2][0]*B[0][2] + A[2][1]*B[1][2] + A[2][2]*B[2][2] + A[2][3]*B[3][2] + C[2][2];
+        X[2][3] = A[2][0]*B[0][3] + A[2][1]*B[1][3] + A[2][2]*B[2][3] + A[2][3]*B[3][3] + C[2][3];
+        X[3][0] = A[3][0]*B[0][0] + A[3][1]*B[1][0] + A[3][2]*B[2][0] + A[3][3]*B[3][0] + C[3][0];
+        X[3][1] = A[3][0]*B[0][1] + A[3][1]*B[1][1] + A[3][2]*B[2][1] + A[3][3]*B[3][1] + C[3][1];
+        X[3][2] = A[3][0]*B[0][2] + A[3][1]*B[1][2] + A[3][2]*B[2][2] + A[3][3]*B[3][2] + C[3][2];
+        X[3][3] = A[3][0]*B[0][3] + A[3][1]*B[1][3] + A[3][2]*B[2][3] + A[3][3]*B[3][3] + C[3][3];'''
+    )
+
+def test_1xN_vecs():
+    gl = glsl_code
+    for i in range(1,10):
+        A = Matrix(range(i))
+        assert gl(A.transpose()) == gl(A)
+        assert gl(A,mat_transpose=True) == gl(A)
+        if i > 1:
+            if i <= 4:
+                assert gl(A) == 'vec%s(%s)' % (i,', '.join(str(s) for s in range(i)))
+            else:
+                assert gl(A) == 'float[%s](%s)' % (i,', '.join(str(s) for s in range(i)))
+
+def test_MxN_mats():
+    generatedAssertions='def test_misc_mats():\n'
+    for i in range(1,6):
+        for j in range(1,6):
+            A = Matrix([[x + y*j for x in range(j)] for y in range(i)])
+            gl = glsl_code(A)
+            glTransposed = glsl_code(A,mat_transpose=True)
+            generatedAssertions+='    mat = '+StrPrinter()._print(A)+'\n\n'
+            generatedAssertions+='    gl = \'\'\''+gl+'\'\'\'\n'
+            generatedAssertions+='    glTransposed = \'\'\''+glTransposed+'\'\'\'\n\n'
+            generatedAssertions+='    assert glsl_code(mat) == gl\n'
+            generatedAssertions+='    assert glsl_code(mat,mat_transpose=True) == glTransposed\n'
+            if i == 1 and j == 1:
+                assert gl == '0'
+            elif i <= 4 and j <= 4 and i>1 and j>1:
+                assert gl.startswith('mat%s' % j)
+                assert glTransposed.startswith('mat%s' % i)
+            elif i == 1 and j <= 4:
+                assert gl.startswith('vec')
+            elif j == 1 and i <= 4:
+                assert gl.startswith('vec')
+            elif i == 1:
+                assert gl.startswith('float[%s]('% j*i)
+                assert glTransposed.startswith('float[%s]('% j*i)
+            elif j == 1:
+                assert gl.startswith('float[%s]('% i*j)
+                assert glTransposed.startswith('float[%s]('% i*j)
+            else:
+                assert gl.startswith('float[%s](' % (i*j))
+                assert glTransposed.startswith('float[%s](' % (i*j))
+                glNested = glsl_code(A,mat_nested=True)
+                glNestedTransposed = glsl_code(A,mat_transpose=True,mat_nested=True)
+                assert glNested.startswith('float[%s][%s]' % (i,j))
+                assert glNestedTransposed.startswith('float[%s][%s]' % (j,i))
+                generatedAssertions+='    glNested = \'\'\''+glNested+'\'\'\'\n'
+                generatedAssertions+='    glNestedTransposed = \'\'\''+glNestedTransposed+'\'\'\'\n\n'
+                generatedAssertions+='    assert glsl_code(mat,mat_nested=True) == glNested\n'
+                generatedAssertions+='    assert glsl_code(mat,mat_nested=True,mat_transpose=True) == glNestedTransposed\n\n'
+    generateAssertions = False # set this to true to write bake these generated tests to a file
+    if generateAssertions:
+        gen = open('test_glsl_generated_matrices.py','w')
+        gen.write(generatedAssertions)
+        gen.close()
+
+
+# these assertions were generated from the previous function
+# glsl has complicated rules and this makes it easier to look over all the cases
+def test_misc_mats():
+
+    mat = Matrix([[0]])
+
+    gl = '''0'''
+    glTransposed = '''0'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([[0, 1]])
+
+    gl = '''vec2(0, 1)'''
+    glTransposed = '''vec2(0, 1)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([[0, 1, 2]])
+
+    gl = '''vec3(0, 1, 2)'''
+    glTransposed = '''vec3(0, 1, 2)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([[0, 1, 2, 3]])
+
+    gl = '''vec4(0, 1, 2, 3)'''
+    glTransposed = '''vec4(0, 1, 2, 3)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([[0, 1, 2, 3, 4]])
+
+    gl = '''float[5](0, 1, 2, 3, 4)'''
+    glTransposed = '''float[5](0, 1, 2, 3, 4)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[0],
+[1]])
+
+    gl = '''vec2(0, 1)'''
+    glTransposed = '''vec2(0, 1)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[0, 1],
+[2, 3]])
+
+    gl = '''mat2(0, 1, 2, 3)'''
+    glTransposed = '''mat2(0, 2, 1, 3)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[0, 1, 2],
+[3, 4, 5]])
+
+    gl = '''mat3x2(0, 1, 2, 3, 4, 5)'''
+    glTransposed = '''mat2x3(0, 3, 1, 4, 2, 5)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[0, 1, 2, 3],
+[4, 5, 6, 7]])
+
+    gl = '''mat4x2(0, 1, 2, 3, 4, 5, 6, 7)'''
+    glTransposed = '''mat2x4(0, 4, 1, 5, 2, 6, 3, 7)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[0, 1, 2, 3, 4],
+[5, 6, 7, 8, 9]])
+
+    gl = '''float[10](
+   0, 1, 2, 3, 4,
+   5, 6, 7, 8, 9
+) /* a 2x5 matrix */'''
+    glTransposed = '''float[10](
+   0, 5,
+   1, 6,
+   2, 7,
+   3, 8,
+   4, 9
+) /* a 5x2 matrix */'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+    glNested = '''float[2][5](
+   float[](0, 1, 2, 3, 4),
+   float[](5, 6, 7, 8, 9)
+)'''
+    glNestedTransposed = '''float[5][2](
+   float[](0, 5),
+   float[](1, 6),
+   float[](2, 7),
+   float[](3, 8),
+   float[](4, 9)
+)'''
+
+    assert glsl_code(mat,mat_nested=True) == glNested
+    assert glsl_code(mat,mat_nested=True,mat_transpose=True) == glNestedTransposed
+
+    mat = Matrix([
+[0],
+[1],
+[2]])
+
+    gl = '''vec3(0, 1, 2)'''
+    glTransposed = '''vec3(0, 1, 2)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[0, 1],
+[2, 3],
+[4, 5]])
+
+    gl = '''mat2x3(0, 1, 2, 3, 4, 5)'''
+    glTransposed = '''mat3x2(0, 2, 4, 1, 3, 5)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[0, 1, 2],
+[3, 4, 5],
+[6, 7, 8]])
+
+    gl = '''mat3(0, 1, 2, 3, 4, 5, 6, 7, 8)'''
+    glTransposed = '''mat3(0, 3, 6, 1, 4, 7, 2, 5, 8)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[0, 1,  2,  3],
+[4, 5,  6,  7],
+[8, 9, 10, 11]])
+
+    gl = '''mat4x3(0, 1,  2,  3, 4, 5,  6,  7, 8, 9, 10, 11)'''
+    glTransposed = '''mat3x4(0, 4,  8, 1, 5,  9, 2, 6, 10, 3, 7, 11)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[ 0,  1,  2,  3,  4],
+[ 5,  6,  7,  8,  9],
+[10, 11, 12, 13, 14]])
+
+    gl = '''float[15](
+   0,  1,  2,  3,  4,
+   5,  6,  7,  8,  9,
+   10, 11, 12, 13, 14
+) /* a 3x5 matrix */'''
+    glTransposed = '''float[15](
+   0, 5, 10,
+   1, 6, 11,
+   2, 7, 12,
+   3, 8, 13,
+   4, 9, 14
+) /* a 5x3 matrix */'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+    glNested = '''float[3][5](
+   float[]( 0,  1,  2,  3,  4),
+   float[]( 5,  6,  7,  8,  9),
+   float[](10, 11, 12, 13, 14)
+)'''
+    glNestedTransposed = '''float[5][3](
+   float[](0, 5, 10),
+   float[](1, 6, 11),
+   float[](2, 7, 12),
+   float[](3, 8, 13),
+   float[](4, 9, 14)
+)'''
+
+    assert glsl_code(mat,mat_nested=True) == glNested
+    assert glsl_code(mat,mat_nested=True,mat_transpose=True) == glNestedTransposed
+
+    mat = Matrix([
+[0],
+[1],
+[2],
+[3]])
+
+    gl = '''vec4(0, 1, 2, 3)'''
+    glTransposed = '''vec4(0, 1, 2, 3)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[0, 1],
+[2, 3],
+[4, 5],
+[6, 7]])
+
+    gl = '''mat2x4(0, 1, 2, 3, 4, 5, 6, 7)'''
+    glTransposed = '''mat4x2(0, 2, 4, 6, 1, 3, 5, 7)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[0,  1,  2],
+[3,  4,  5],
+[6,  7,  8],
+[9, 10, 11]])
+
+    gl = '''mat3x4(0,  1,  2, 3,  4,  5, 6,  7,  8, 9, 10, 11)'''
+    glTransposed = '''mat4x3(0, 3, 6,  9, 1, 4, 7, 10, 2, 5, 8, 11)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[ 0,  1,  2,  3],
+[ 4,  5,  6,  7],
+[ 8,  9, 10, 11],
+[12, 13, 14, 15]])
+
+    gl = '''mat4( 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15)'''
+    glTransposed = '''mat4(0, 4,  8, 12, 1, 5,  9, 13, 2, 6, 10, 14, 3, 7, 11, 15)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[ 0,  1,  2,  3,  4],
+[ 5,  6,  7,  8,  9],
+[10, 11, 12, 13, 14],
+[15, 16, 17, 18, 19]])
+
+    gl = '''float[20](
+   0,  1,  2,  3,  4,
+   5,  6,  7,  8,  9,
+   10, 11, 12, 13, 14,
+   15, 16, 17, 18, 19
+) /* a 4x5 matrix */'''
+    glTransposed = '''float[20](
+   0, 5, 10, 15,
+   1, 6, 11, 16,
+   2, 7, 12, 17,
+   3, 8, 13, 18,
+   4, 9, 14, 19
+) /* a 5x4 matrix */'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+    glNested = '''float[4][5](
+   float[]( 0,  1,  2,  3,  4),
+   float[]( 5,  6,  7,  8,  9),
+   float[](10, 11, 12, 13, 14),
+   float[](15, 16, 17, 18, 19)
+)'''
+    glNestedTransposed = '''float[5][4](
+   float[](0, 5, 10, 15),
+   float[](1, 6, 11, 16),
+   float[](2, 7, 12, 17),
+   float[](3, 8, 13, 18),
+   float[](4, 9, 14, 19)
+)'''
+
+    assert glsl_code(mat,mat_nested=True) == glNested
+    assert glsl_code(mat,mat_nested=True,mat_transpose=True) == glNestedTransposed
+
+    mat = Matrix([
+[0],
+[1],
+[2],
+[3],
+[4]])
+
+    gl = '''float[5](0, 1, 2, 3, 4)'''
+    glTransposed = '''float[5](0, 1, 2, 3, 4)'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+
+    mat = Matrix([
+[0, 1],
+[2, 3],
+[4, 5],
+[6, 7],
+[8, 9]])
+
+    gl = '''float[10](
+   0, 1,
+   2, 3,
+   4, 5,
+   6, 7,
+   8, 9
+) /* a 5x2 matrix */'''
+    glTransposed = '''float[10](
+   0, 2, 4, 6, 8,
+   1, 3, 5, 7, 9
+) /* a 2x5 matrix */'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+    glNested = '''float[5][2](
+   float[](0, 1),
+   float[](2, 3),
+   float[](4, 5),
+   float[](6, 7),
+   float[](8, 9)
+)'''
+    glNestedTransposed = '''float[2][5](
+   float[](0, 2, 4, 6, 8),
+   float[](1, 3, 5, 7, 9)
+)'''
+
+    assert glsl_code(mat,mat_nested=True) == glNested
+    assert glsl_code(mat,mat_nested=True,mat_transpose=True) == glNestedTransposed
+
+    mat = Matrix([
+[ 0,  1,  2],
+[ 3,  4,  5],
+[ 6,  7,  8],
+[ 9, 10, 11],
+[12, 13, 14]])
+
+    gl = '''float[15](
+   0,  1,  2,
+   3,  4,  5,
+   6,  7,  8,
+   9, 10, 11,
+   12, 13, 14
+) /* a 5x3 matrix */'''
+    glTransposed = '''float[15](
+   0, 3, 6,  9, 12,
+   1, 4, 7, 10, 13,
+   2, 5, 8, 11, 14
+) /* a 3x5 matrix */'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+    glNested = '''float[5][3](
+   float[]( 0,  1,  2),
+   float[]( 3,  4,  5),
+   float[]( 6,  7,  8),
+   float[]( 9, 10, 11),
+   float[](12, 13, 14)
+)'''
+    glNestedTransposed = '''float[3][5](
+   float[](0, 3, 6,  9, 12),
+   float[](1, 4, 7, 10, 13),
+   float[](2, 5, 8, 11, 14)
+)'''
+
+    assert glsl_code(mat,mat_nested=True) == glNested
+    assert glsl_code(mat,mat_nested=True,mat_transpose=True) == glNestedTransposed
+
+    mat = Matrix([
+[ 0,  1,  2,  3],
+[ 4,  5,  6,  7],
+[ 8,  9, 10, 11],
+[12, 13, 14, 15],
+[16, 17, 18, 19]])
+
+    gl = '''float[20](
+   0,  1,  2,  3,
+   4,  5,  6,  7,
+   8,  9, 10, 11,
+   12, 13, 14, 15,
+   16, 17, 18, 19
+) /* a 5x4 matrix */'''
+    glTransposed = '''float[20](
+   0, 4,  8, 12, 16,
+   1, 5,  9, 13, 17,
+   2, 6, 10, 14, 18,
+   3, 7, 11, 15, 19
+) /* a 4x5 matrix */'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+    glNested = '''float[5][4](
+   float[]( 0,  1,  2,  3),
+   float[]( 4,  5,  6,  7),
+   float[]( 8,  9, 10, 11),
+   float[](12, 13, 14, 15),
+   float[](16, 17, 18, 19)
+)'''
+    glNestedTransposed = '''float[4][5](
+   float[](0, 4,  8, 12, 16),
+   float[](1, 5,  9, 13, 17),
+   float[](2, 6, 10, 14, 18),
+   float[](3, 7, 11, 15, 19)
+)'''
+
+    assert glsl_code(mat,mat_nested=True) == glNested
+    assert glsl_code(mat,mat_nested=True,mat_transpose=True) == glNestedTransposed
+
+    mat = Matrix([
+[ 0,  1,  2,  3,  4],
+[ 5,  6,  7,  8,  9],
+[10, 11, 12, 13, 14],
+[15, 16, 17, 18, 19],
+[20, 21, 22, 23, 24]])
+
+    gl = '''float[25](
+   0,  1,  2,  3,  4,
+   5,  6,  7,  8,  9,
+   10, 11, 12, 13, 14,
+   15, 16, 17, 18, 19,
+   20, 21, 22, 23, 24
+) /* a 5x5 matrix */'''
+    glTransposed = '''float[25](
+   0, 5, 10, 15, 20,
+   1, 6, 11, 16, 21,
+   2, 7, 12, 17, 22,
+   3, 8, 13, 18, 23,
+   4, 9, 14, 19, 24
+) /* a 5x5 matrix */'''
+
+    assert glsl_code(mat) == gl
+    assert glsl_code(mat,mat_transpose=True) == glTransposed
+    glNested = '''float[5][5](
+   float[]( 0,  1,  2,  3,  4),
+   float[]( 5,  6,  7,  8,  9),
+   float[](10, 11, 12, 13, 14),
+   float[](15, 16, 17, 18, 19),
+   float[](20, 21, 22, 23, 24)
+)'''
+    glNestedTransposed = '''float[5][5](
+   float[](0, 5, 10, 15, 20),
+   float[](1, 6, 11, 16, 21),
+   float[](2, 7, 12, 17, 22),
+   float[](3, 8, 13, 18, 23),
+   float[](4, 9, 14, 19, 24)
+)'''
+
+    assert glsl_code(mat,mat_nested=True) == glNested
+    assert glsl_code(mat,mat_nested=True,mat_transpose=True) == glNestedTransposed

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_gtk.py

@@ -0,0 +1,18 @@
+from sympy.functions.elementary.trigonometric import sin
+from sympy.printing.gtk import print_gtk
+from sympy.testing.pytest import XFAIL, raises
+
+# this test fails if python-lxml isn't installed. We don't want to depend on
+# anything with SymPy
+
+
+@XFAIL
+def test_1():
+    from sympy.abc import x
+    print_gtk(x**2, start_viewer=False)
+    print_gtk(x**2 + sin(x)/4, start_viewer=False)
+
+
+def test_settings():
+    from sympy.abc import x
+    raises(TypeError, lambda: print_gtk(x, method="garbage"))

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_jax.py

@@ -0,0 +1,347 @@
+from sympy.concrete.summations import Sum
+from sympy.core.mod import Mod
+from sympy.core.relational import (Equality, Unequality)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.matrices.expressions.blockmatrix import BlockMatrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.special import Identity
+from sympy.utilities.lambdify import lambdify
+
+from sympy.abc import x, i, j, a, b, c, d
+from sympy.core import Pow
+from sympy.codegen.matrix_nodes import MatrixSolve
+from sympy.codegen.numpy_nodes import logaddexp, logaddexp2
+from sympy.codegen.cfunctions import log1p, expm1, hypot, log10, exp2, log2, Sqrt
+from sympy.tensor.array import Array
+from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct, ArrayAdd, \
+    PermuteDims, ArrayDiagonal
+from sympy.printing.numpy import JaxPrinter, _jax_known_constants, _jax_known_functions
+from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array
+
+from sympy.testing.pytest import skip, raises
+from sympy.external import import_module
+
+# Unlike NumPy which will aggressively promote operands to double precision,
+# jax always uses single precision. Double precision in jax can be
+# configured before the call to `import jax`, however this must be explicitly
+# configured and is not fully supported. Thus, the tests here have been modified
+# from the tests in test_numpy.py, only in the fact that they assert lambdify
+# function accuracy to only single precision accuracy.
+# https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision
+
+jax = import_module('jax')
+
+if jax:
+    deafult_float_info = jax.numpy.finfo(jax.numpy.array([]).dtype)
+    JAX_DEFAULT_EPSILON = deafult_float_info.eps
+
+def test_jax_piecewise_regression():
+    """
+    NumPyPrinter needs to print Piecewise()'s choicelist as a list to avoid
+    breaking compatibility with numpy 1.8. This is not necessary in numpy 1.9+.
+    See gh-9747 and gh-9749 for details.
+    """
+    printer = JaxPrinter()
+    p = Piecewise((1, x < 0), (0, True))
+    assert printer.doprint(p) == \
+        'jax.numpy.select([jax.numpy.less(x, 0),True], [1,0], default=jax.numpy.nan)'
+    assert printer.module_imports == {'jax.numpy': {'select', 'less', 'nan'}}
+
+
+def test_jax_logaddexp():
+    lae = logaddexp(a, b)
+    assert JaxPrinter().doprint(lae) == 'jax.numpy.logaddexp(a, b)'
+    lae2 = logaddexp2(a, b)
+    assert JaxPrinter().doprint(lae2) == 'jax.numpy.logaddexp2(a, b)'
+
+
+def test_jax_sum():
+    if not jax:
+        skip("JAX not installed")
+
+    s = Sum(x ** i, (i, a, b))
+    f = lambdify((a, b, x), s, 'jax')
+
+    a_, b_ = 0, 10
+    x_ = jax.numpy.linspace(-1, +1, 10)
+    assert jax.numpy.allclose(f(a_, b_, x_), sum(x_ ** i_ for i_ in range(a_, b_ + 1)))
+
+    s = Sum(i * x, (i, a, b))
+    f = lambdify((a, b, x), s, 'jax')
+
+    a_, b_ = 0, 10
+    x_ = jax.numpy.linspace(-1, +1, 10)
+    assert jax.numpy.allclose(f(a_, b_, x_), sum(i_ * x_ for i_ in range(a_, b_ + 1)))
+
+
+def test_jax_multiple_sums():
+    if not jax:
+        skip("JAX not installed")
+
+    s = Sum((x + j) * i, (i, a, b), (j, c, d))
+    f = lambdify((a, b, c, d, x), s, 'jax')
+
+    a_, b_ = 0, 10
+    c_, d_ = 11, 21
+    x_ = jax.numpy.linspace(-1, +1, 10)
+    assert jax.numpy.allclose(f(a_, b_, c_, d_, x_),
+                       sum((x_ + j_) * i_ for i_ in range(a_, b_ + 1) for j_ in range(c_, d_ + 1)))
+
+
+def test_jax_codegen_einsum():
+    if not jax:
+        skip("JAX not installed")
+
+    M = MatrixSymbol("M", 2, 2)
+    N = MatrixSymbol("N", 2, 2)
+
+    cg = convert_matrix_to_array(M * N)
+    f = lambdify((M, N), cg, 'jax')
+
+    ma = jax.numpy.array([[1, 2], [3, 4]])
+    mb = jax.numpy.array([[1,-2], [-1, 3]])
+    assert (f(ma, mb) == jax.numpy.matmul(ma, mb)).all()
+
+
+def test_jax_codegen_extra():
+    if not jax:
+        skip("JAX not installed")
+
+    M = MatrixSymbol("M", 2, 2)
+    N = MatrixSymbol("N", 2, 2)
+    P = MatrixSymbol("P", 2, 2)
+    Q = MatrixSymbol("Q", 2, 2)
+    ma = jax.numpy.array([[1, 2], [3, 4]])
+    mb = jax.numpy.array([[1,-2], [-1, 3]])
+    mc = jax.numpy.array([[2, 0], [1, 2]])
+    md = jax.numpy.array([[1,-1], [4, 7]])
+
+    cg = ArrayTensorProduct(M, N)
+    f = lambdify((M, N), cg, 'jax')
+    assert (f(ma, mb) == jax.numpy.einsum(ma, [0, 1], mb, [2, 3])).all()
+
+    cg = ArrayAdd(M, N)
+    f = lambdify((M, N), cg, 'jax')
+    assert (f(ma, mb) == ma+mb).all()
+
+    cg = ArrayAdd(M, N, P)
+    f = lambdify((M, N, P), cg, 'jax')
+    assert (f(ma, mb, mc) == ma+mb+mc).all()
+
+    cg = ArrayAdd(M, N, P, Q)
+    f = lambdify((M, N, P, Q), cg, 'jax')
+    assert (f(ma, mb, mc, md) == ma+mb+mc+md).all()
+
+    cg = PermuteDims(M, [1, 0])
+    f = lambdify((M,), cg, 'jax')
+    assert (f(ma) == ma.T).all()
+
+    cg = PermuteDims(ArrayTensorProduct(M, N), [1, 2, 3, 0])
+    f = lambdify((M, N), cg, 'jax')
+    assert (f(ma, mb) == jax.numpy.transpose(jax.numpy.einsum(ma, [0, 1], mb, [2, 3]), (1, 2, 3, 0))).all()
+
+    cg = ArrayDiagonal(ArrayTensorProduct(M, N), (1, 2))
+    f = lambdify((M, N), cg, 'jax')
+    assert (f(ma, mb) == jax.numpy.diagonal(jax.numpy.einsum(ma, [0, 1], mb, [2, 3]), axis1=1, axis2=2)).all()
+
+
+def test_jax_relational():
+    if not jax:
+        skip("JAX not installed")
+
+    e = Equality(x, 1)
+
+    f = lambdify((x,), e, 'jax')
+    x_ = jax.numpy.array([0, 1, 2])
+    assert jax.numpy.array_equal(f(x_), [False, True, False])
+
+    e = Unequality(x, 1)
+
+    f = lambdify((x,), e, 'jax')
+    x_ = jax.numpy.array([0, 1, 2])
+    assert jax.numpy.array_equal(f(x_), [True, False, True])
+
+    e = (x < 1)
+
+    f = lambdify((x,), e, 'jax')
+    x_ = jax.numpy.array([0, 1, 2])
+    assert jax.numpy.array_equal(f(x_), [True, False, False])
+
+    e = (x <= 1)
+
+    f = lambdify((x,), e, 'jax')
+    x_ = jax.numpy.array([0, 1, 2])
+    assert jax.numpy.array_equal(f(x_), [True, True, False])
+
+    e = (x > 1)
+
+    f = lambdify((x,), e, 'jax')
+    x_ = jax.numpy.array([0, 1, 2])
+    assert jax.numpy.array_equal(f(x_), [False, False, True])
+
+    e = (x >= 1)
+
+    f = lambdify((x,), e, 'jax')
+    x_ = jax.numpy.array([0, 1, 2])
+    assert jax.numpy.array_equal(f(x_), [False, True, True])
+
+    # Multi-condition expressions
+    e = (x >= 1) & (x < 2)
+    f = lambdify((x,), e, 'jax')
+    x_ = jax.numpy.array([0, 1, 2])
+    assert jax.numpy.array_equal(f(x_), [False, True, False])
+
+    e = (x >= 1) | (x < 2)
+    f = lambdify((x,), e, 'jax')
+    x_ = jax.numpy.array([0, 1, 2])
+    assert jax.numpy.array_equal(f(x_), [True, True, True])
+
+def test_jax_mod():
+    if not jax:
+        skip("JAX not installed")
+
+    e = Mod(a, b)
+    f = lambdify((a, b), e, 'jax')
+
+    a_ = jax.numpy.array([0, 1, 2, 3])
+    b_ = 2
+    assert jax.numpy.array_equal(f(a_, b_), [0, 1, 0, 1])
+
+    a_ = jax.numpy.array([0, 1, 2, 3])
+    b_ = jax.numpy.array([2, 2, 2, 2])
+    assert jax.numpy.array_equal(f(a_, b_), [0, 1, 0, 1])
+
+    a_ = jax.numpy.array([2, 3, 4, 5])
+    b_ = jax.numpy.array([2, 3, 4, 5])
+    assert jax.numpy.array_equal(f(a_, b_), [0, 0, 0, 0])
+
+
+def test_jax_pow():
+    if not jax:
+        skip('JAX not installed')
+
+    expr = Pow(2, -1, evaluate=False)
+    f = lambdify([], expr, 'jax')
+    assert f() == 0.5
+
+
+def test_jax_expm1():
+    if not jax:
+        skip("JAX not installed")
+
+    f = lambdify((a,), expm1(a), 'jax')
+    assert abs(f(1e-10) - 1e-10 - 5e-21) <= 1e-10 * JAX_DEFAULT_EPSILON
+
+
+def test_jax_log1p():
+    if not jax:
+        skip("JAX not installed")
+
+    f = lambdify((a,), log1p(a), 'jax')
+    assert abs(f(1e-99) - 1e-99) <= 1e-99 * JAX_DEFAULT_EPSILON
+
+def test_jax_hypot():
+    if not jax:
+        skip("JAX not installed")
+    assert abs(lambdify((a, b), hypot(a, b), 'jax')(3, 4) - 5) <= JAX_DEFAULT_EPSILON
+
+def test_jax_log10():
+    if not jax:
+        skip("JAX not installed")
+
+    assert abs(lambdify((a,), log10(a), 'jax')(100) - 2) <= JAX_DEFAULT_EPSILON
+
+
+def test_jax_exp2():
+    if not jax:
+        skip("JAX not installed")
+    assert abs(lambdify((a,), exp2(a), 'jax')(5) - 32) <= JAX_DEFAULT_EPSILON
+
+
+def test_jax_log2():
+    if not jax:
+        skip("JAX not installed")
+    assert abs(lambdify((a,), log2(a), 'jax')(256) - 8) <= JAX_DEFAULT_EPSILON
+
+
+def test_jax_Sqrt():
+    if not jax:
+        skip("JAX not installed")
+    assert abs(lambdify((a,), Sqrt(a), 'jax')(4) - 2) <= JAX_DEFAULT_EPSILON
+
+
+def test_jax_sqrt():
+    if not jax:
+        skip("JAX not installed")
+    assert abs(lambdify((a,), sqrt(a), 'jax')(4) - 2) <= JAX_DEFAULT_EPSILON
+
+
+def test_jax_matsolve():
+    if not jax:
+        skip("JAX not installed")
+
+    M = MatrixSymbol("M", 3, 3)
+    x = MatrixSymbol("x", 3, 1)
+
+    expr = M**(-1) * x + x
+    matsolve_expr = MatrixSolve(M, x) + x
+
+    f = lambdify((M, x), expr, 'jax')
+    f_matsolve = lambdify((M, x), matsolve_expr, 'jax')
+
+    m0 = jax.numpy.array([[1, 2, 3], [3, 2, 5], [5, 6, 7]])
+    assert jax.numpy.linalg.matrix_rank(m0) == 3
+
+    x0 = jax.numpy.array([3, 4, 5])
+
+    assert jax.numpy.allclose(f_matsolve(m0, x0), f(m0, x0))
+
+
+def test_16857():
+    if not jax:
+        skip("JAX not installed")
+
+    a_1 = MatrixSymbol('a_1', 10, 3)
+    a_2 = MatrixSymbol('a_2', 10, 3)
+    a_3 = MatrixSymbol('a_3', 10, 3)
+    a_4 = MatrixSymbol('a_4', 10, 3)
+    A = BlockMatrix([[a_1, a_2], [a_3, a_4]])
+    assert A.shape == (20, 6)
+
+    printer = JaxPrinter()
+    assert printer.doprint(A) == 'jax.numpy.block([[a_1, a_2], [a_3, a_4]])'
+
+
+def test_issue_17006():
+    if not jax:
+        skip("JAX not installed")
+
+    M = MatrixSymbol("M", 2, 2)
+
+    f = lambdify(M, M + Identity(2), 'jax')
+    ma = jax.numpy.array([[1, 2], [3, 4]])
+    mr = jax.numpy.array([[2, 2], [3, 5]])
+
+    assert (f(ma) == mr).all()
+
+    from sympy.core.symbol import symbols
+    n = symbols('n', integer=True)
+    N = MatrixSymbol("M", n, n)
+    raises(NotImplementedError, lambda: lambdify(N, N + Identity(n), 'jax'))
+
+def test_jax_array():
+    assert JaxPrinter().doprint(Array(((1, 2), (3, 5)))) == 'jax.numpy.array([[1, 2], [3, 5]])'
+    assert JaxPrinter().doprint(Array((1, 2))) == 'jax.numpy.array((1, 2))'
+
+def test_jax_known_funcs_consts():
+    assert _jax_known_constants['NaN'] == 'jax.numpy.nan'
+    assert _jax_known_constants['EulerGamma'] == 'jax.numpy.euler_gamma'
+
+    assert _jax_known_functions['acos'] == 'jax.numpy.arccos'
+    assert _jax_known_functions['log'] == 'jax.numpy.log'
+
+def test_jax_print_methods():
+    prntr = JaxPrinter()
+    assert hasattr(prntr, '_print_acos')
+    assert hasattr(prntr, '_print_log')

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_jscode.py

@@ -0,0 +1,396 @@
+from sympy.core import (pi, oo, symbols, Rational, Integer, GoldenRatio,
+                        EulerGamma, Catalan, Lambda, Dummy, S, Eq, Ne, Le,
+                        Lt, Gt, Ge, Mod)
+from sympy.functions import (Piecewise, sin, cos, Abs, exp, ceiling, sqrt,
+                             sinh, cosh, tanh, asin, acos, acosh, Max, Min)
+from sympy.testing.pytest import raises
+from sympy.printing.jscode import JavascriptCodePrinter
+from sympy.utilities.lambdify import implemented_function
+from sympy.tensor import IndexedBase, Idx
+from sympy.matrices import Matrix, MatrixSymbol
+
+from sympy.printing.jscode import jscode
+
+x, y, z = symbols('x,y,z')
+
+
+def test_printmethod():
+    assert jscode(Abs(x)) == "Math.abs(x)"
+
+
+def test_jscode_sqrt():
+    assert jscode(sqrt(x)) == "Math.sqrt(x)"
+    assert jscode(x**0.5) == "Math.sqrt(x)"
+    assert jscode(x**(S.One/3)) == "Math.cbrt(x)"
+
+
+def test_jscode_Pow():
+    g = implemented_function('g', Lambda(x, 2*x))
+    assert jscode(x**3) == "Math.pow(x, 3)"
+    assert jscode(x**(y**3)) == "Math.pow(x, Math.pow(y, 3))"
+    assert jscode(1/(g(x)*3.5)**(x - y**x)/(x**2 + y)) == \
+        "Math.pow(3.5*2*x, -x + Math.pow(y, x))/(Math.pow(x, 2) + y)"
+    assert jscode(x**-1.0) == '1/x'
+
+
+def test_jscode_constants_mathh():
+    assert jscode(exp(1)) == "Math.E"
+    assert jscode(pi) == "Math.PI"
+    assert jscode(oo) == "Number.POSITIVE_INFINITY"
+    assert jscode(-oo) == "Number.NEGATIVE_INFINITY"
+
+
+def test_jscode_constants_other():
+    assert jscode(
+        2*GoldenRatio) == "var GoldenRatio = %s;\n2*GoldenRatio" % GoldenRatio.evalf(17)
+    assert jscode(2*Catalan) == "var Catalan = %s;\n2*Catalan" % Catalan.evalf(17)
+    assert jscode(
+        2*EulerGamma) == "var EulerGamma = %s;\n2*EulerGamma" % EulerGamma.evalf(17)
+
+
+def test_jscode_Rational():
+    assert jscode(Rational(3, 7)) == "3/7"
+    assert jscode(Rational(18, 9)) == "2"
+    assert jscode(Rational(3, -7)) == "-3/7"
+    assert jscode(Rational(-3, -7)) == "3/7"
+
+
+def test_Relational():
+    assert jscode(Eq(x, y)) == "x == y"
+    assert jscode(Ne(x, y)) == "x != y"
+    assert jscode(Le(x, y)) == "x <= y"
+    assert jscode(Lt(x, y)) == "x < y"
+    assert jscode(Gt(x, y)) == "x > y"
+    assert jscode(Ge(x, y)) == "x >= y"
+
+
+def test_Mod():
+    assert jscode(Mod(x, y)) == '((x % y) + y) % y'
+    assert jscode(Mod(x, x + y)) == '((x % (x + y)) + (x + y)) % (x + y)'
+    p1, p2 = symbols('p1 p2', positive=True)
+    assert jscode(Mod(p1, p2)) == 'p1 % p2'
+    assert jscode(Mod(p1, p2 + 3)) == 'p1 % (p2 + 3)'
+    assert jscode(Mod(-3, -7, evaluate=False)) == '(-3) % (-7)'
+    assert jscode(-Mod(p1, p2)) == '-(p1 % p2)'
+    assert jscode(x*Mod(p1, p2)) == 'x*(p1 % p2)'
+
+
+def test_jscode_Integer():
+    assert jscode(Integer(67)) == "67"
+    assert jscode(Integer(-1)) == "-1"
+
+
+def test_jscode_functions():
+    assert jscode(sin(x) ** cos(x)) == "Math.pow(Math.sin(x), Math.cos(x))"
+    assert jscode(sinh(x) * cosh(x)) == "Math.sinh(x)*Math.cosh(x)"
+    assert jscode(Max(x, y) + Min(x, y)) == "Math.max(x, y) + Math.min(x, y)"
+    assert jscode(tanh(x)*acosh(y)) == "Math.tanh(x)*Math.acosh(y)"
+    assert jscode(asin(x)-acos(y)) == "-Math.acos(y) + Math.asin(x)"
+
+
+def test_jscode_inline_function():
+    x = symbols('x')
+    g = implemented_function('g', Lambda(x, 2*x))
+    assert jscode(g(x)) == "2*x"
+    g = implemented_function('g', Lambda(x, 2*x/Catalan))
+    assert jscode(g(x)) == "var Catalan = %s;\n2*x/Catalan" % Catalan.evalf(17)
+    A = IndexedBase('A')
+    i = Idx('i', symbols('n', integer=True))
+    g = implemented_function('g', Lambda(x, x*(1 + x)*(2 + x)))
+    assert jscode(g(A[i]), assign_to=A[i]) == (
+        "for (var i=0; i<n; i++){\n"
+        "   A[i] = (A[i] + 1)*(A[i] + 2)*A[i];\n"
+        "}"
+    )
+
+
+def test_jscode_exceptions():
+    assert jscode(ceiling(x)) == "Math.ceil(x)"
+    assert jscode(Abs(x)) == "Math.abs(x)"
+
+
+def test_jscode_boolean():
+    assert jscode(x & y) == "x && y"
+    assert jscode(x | y) == "x || y"
+    assert jscode(~x) == "!x"
+    assert jscode(x & y & z) == "x && y && z"
+    assert jscode(x | y | z) == "x || y || z"
+    assert jscode((x & y) | z) == "z || x && y"
+    assert jscode((x | y) & z) == "z && (x || y)"
+
+
+def test_jscode_Piecewise():
+    expr = Piecewise((x, x < 1), (x**2, True))
+    p = jscode(expr)
+    s = \
+"""\
+((x < 1) ? (
+   x
+)
+: (
+   Math.pow(x, 2)
+))\
+"""
+    assert p == s
+    assert jscode(expr, assign_to="c") == (
+    "if (x < 1) {\n"
+    "   c = x;\n"
+    "}\n"
+    "else {\n"
+    "   c = Math.pow(x, 2);\n"
+    "}")
+    # Check that Piecewise without a True (default) condition error
+    expr = Piecewise((x, x < 1), (x**2, x > 1), (sin(x), x > 0))
+    raises(ValueError, lambda: jscode(expr))
+
+
+def test_jscode_Piecewise_deep():
+    p = jscode(2*Piecewise((x, x < 1), (x**2, True)))
+    s = \
+"""\
+2*((x < 1) ? (
+   x
+)
+: (
+   Math.pow(x, 2)
+))\
+"""
+    assert p == s
+
+
+def test_jscode_settings():
+    raises(TypeError, lambda: jscode(sin(x), method="garbage"))
+
+
+def test_jscode_Indexed():
+    n, m, o = symbols('n m o', integer=True)
+    i, j, k = Idx('i', n), Idx('j', m), Idx('k', o)
+    p = JavascriptCodePrinter()
+    p._not_c = set()
+
+    x = IndexedBase('x')[j]
+    assert p._print_Indexed(x) == 'x[j]'
+    A = IndexedBase('A')[i, j]
+    assert p._print_Indexed(A) == 'A[%s]' % (m*i+j)
+    B = IndexedBase('B')[i, j, k]
+    assert p._print_Indexed(B) == 'B[%s]' % (i*o*m+j*o+k)
+
+    assert p._not_c == set()
+
+
+def test_jscode_loops_matrix_vector():
+    n, m = symbols('n m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+
+    s = (
+        'for (var i=0; i<m; i++){\n'
+        '   y[i] = 0;\n'
+        '}\n'
+        'for (var i=0; i<m; i++){\n'
+        '   for (var j=0; j<n; j++){\n'
+        '      y[i] = A[n*i + j]*x[j] + y[i];\n'
+        '   }\n'
+        '}'
+    )
+    c = jscode(A[i, j]*x[j], assign_to=y[i])
+    assert c == s
+
+
+def test_dummy_loops():
+    i, m = symbols('i m', integer=True, cls=Dummy)
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx(i, m)
+
+    expected = (
+        'for (var i_%(icount)i=0; i_%(icount)i<m_%(mcount)i; i_%(icount)i++){\n'
+        '   y[i_%(icount)i] = x[i_%(icount)i];\n'
+        '}'
+    ) % {'icount': i.label.dummy_index, 'mcount': m.dummy_index}
+    code = jscode(x[i], assign_to=y[i])
+    assert code == expected
+
+
+def test_jscode_loops_add():
+    n, m = symbols('n m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    z = IndexedBase('z')
+    i = Idx('i', m)
+    j = Idx('j', n)
+
+    s = (
+        'for (var i=0; i<m; i++){\n'
+        '   y[i] = x[i] + z[i];\n'
+        '}\n'
+        'for (var i=0; i<m; i++){\n'
+        '   for (var j=0; j<n; j++){\n'
+        '      y[i] = A[n*i + j]*x[j] + y[i];\n'
+        '   }\n'
+        '}'
+    )
+    c = jscode(A[i, j]*x[j] + x[i] + z[i], assign_to=y[i])
+    assert c == s
+
+
+def test_jscode_loops_multiple_contractions():
+    n, m, o, p = symbols('n m o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+    l = Idx('l', p)
+
+    s = (
+        'for (var i=0; i<m; i++){\n'
+        '   y[i] = 0;\n'
+        '}\n'
+        'for (var i=0; i<m; i++){\n'
+        '   for (var j=0; j<n; j++){\n'
+        '      for (var k=0; k<o; k++){\n'
+        '         for (var l=0; l<p; l++){\n'
+        '            y[i] = a[%s]*b[%s] + y[i];\n' % (i*n*o*p + j*o*p + k*p + l, j*o*p + k*p + l) +\
+        '         }\n'
+        '      }\n'
+        '   }\n'
+        '}'
+    )
+    c = jscode(b[j, k, l]*a[i, j, k, l], assign_to=y[i])
+    assert c == s
+
+
+def test_jscode_loops_addfactor():
+    n, m, o, p = symbols('n m o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    c = IndexedBase('c')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+    l = Idx('l', p)
+
+    s = (
+        'for (var i=0; i<m; i++){\n'
+        '   y[i] = 0;\n'
+        '}\n'
+        'for (var i=0; i<m; i++){\n'
+        '   for (var j=0; j<n; j++){\n'
+        '      for (var k=0; k<o; k++){\n'
+        '         for (var l=0; l<p; l++){\n'
+        '            y[i] = (a[%s] + b[%s])*c[%s] + y[i];\n' % (i*n*o*p + j*o*p + k*p + l, i*n*o*p + j*o*p + k*p + l, j*o*p + k*p + l) +\
+        '         }\n'
+        '      }\n'
+        '   }\n'
+        '}'
+    )
+    c = jscode((a[i, j, k, l] + b[i, j, k, l])*c[j, k, l], assign_to=y[i])
+    assert c == s
+
+
+def test_jscode_loops_multiple_terms():
+    n, m, o, p = symbols('n m o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    c = IndexedBase('c')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+
+    s0 = (
+        'for (var i=0; i<m; i++){\n'
+        '   y[i] = 0;\n'
+        '}\n'
+    )
+    s1 = (
+        'for (var i=0; i<m; i++){\n'
+        '   for (var j=0; j<n; j++){\n'
+        '      for (var k=0; k<o; k++){\n'
+        '         y[i] = b[j]*b[k]*c[%s] + y[i];\n' % (i*n*o + j*o + k) +\
+        '      }\n'
+        '   }\n'
+        '}\n'
+    )
+    s2 = (
+        'for (var i=0; i<m; i++){\n'
+        '   for (var k=0; k<o; k++){\n'
+        '      y[i] = a[%s]*b[k] + y[i];\n' % (i*o + k) +\
+        '   }\n'
+        '}\n'
+    )
+    s3 = (
+        'for (var i=0; i<m; i++){\n'
+        '   for (var j=0; j<n; j++){\n'
+        '      y[i] = a[%s]*b[j] + y[i];\n' % (i*n + j) +\
+        '   }\n'
+        '}\n'
+    )
+    c = jscode(
+        b[j]*a[i, j] + b[k]*a[i, k] + b[j]*b[k]*c[i, j, k], assign_to=y[i])
+    assert (c == s0 + s1 + s2 + s3[:-1] or
+            c == s0 + s1 + s3 + s2[:-1] or
+            c == s0 + s2 + s1 + s3[:-1] or
+            c == s0 + s2 + s3 + s1[:-1] or
+            c == s0 + s3 + s1 + s2[:-1] or
+            c == s0 + s3 + s2 + s1[:-1])
+
+
+def test_Matrix_printing():
+    # Test returning a Matrix
+    mat = Matrix([x*y, Piecewise((2 + x, y>0), (y, True)), sin(z)])
+    A = MatrixSymbol('A', 3, 1)
+    assert jscode(mat, A) == (
+        "A[0] = x*y;\n"
+        "if (y > 0) {\n"
+        "   A[1] = x + 2;\n"
+        "}\n"
+        "else {\n"
+        "   A[1] = y;\n"
+        "}\n"
+        "A[2] = Math.sin(z);")
+    # Test using MatrixElements in expressions
+    expr = Piecewise((2*A[2, 0], x > 0), (A[2, 0], True)) + sin(A[1, 0]) + A[0, 0]
+    assert jscode(expr) == (
+        "((x > 0) ? (\n"
+        "   2*A[2]\n"
+        ")\n"
+        ": (\n"
+        "   A[2]\n"
+        ")) + Math.sin(A[1]) + A[0]")
+    # Test using MatrixElements in a Matrix
+    q = MatrixSymbol('q', 5, 1)
+    M = MatrixSymbol('M', 3, 3)
+    m = Matrix([[sin(q[1,0]), 0, cos(q[2,0])],
+        [q[1,0] + q[2,0], q[3, 0], 5],
+        [2*q[4, 0]/q[1,0], sqrt(q[0,0]) + 4, 0]])
+    assert jscode(m, M) == (
+        "M[0] = Math.sin(q[1]);\n"
+        "M[1] = 0;\n"
+        "M[2] = Math.cos(q[2]);\n"
+        "M[3] = q[1] + q[2];\n"
+        "M[4] = q[3];\n"
+        "M[5] = 5;\n"
+        "M[6] = 2*q[4]/q[1];\n"
+        "M[7] = Math.sqrt(q[0]) + 4;\n"
+        "M[8] = 0;")
+
+
+def test_MatrixElement_printing():
+    # test cases for issue #11821
+    A = MatrixSymbol("A", 1, 3)
+    B = MatrixSymbol("B", 1, 3)
+    C = MatrixSymbol("C", 1, 3)
+
+    assert(jscode(A[0, 0]) == "A[0]")
+    assert(jscode(3 * A[0, 0]) == "3*A[0]")
+
+    F = C[0, 0].subs(C, A - B)
+    assert(jscode(F) == "(A - B)[0]")

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_julia.py

@@ -0,0 +1,388 @@
+from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer,
+                        Tuple, Symbol, Eq, Ne, Le, Lt, Gt, Ge)
+from sympy.core import EulerGamma, GoldenRatio, Catalan, Lambda, Mul, Pow
+from sympy.functions import Piecewise, sqrt, ceiling, exp, sin, cos
+from sympy.testing.pytest import raises
+from sympy.utilities.lambdify import implemented_function
+from sympy.matrices import (eye, Matrix, MatrixSymbol, Identity,
+                            HadamardProduct, SparseMatrix)
+from sympy.functions.special.bessel import (jn, yn, besselj, bessely, besseli,
+                                            besselk, hankel1, hankel2, airyai,
+                                            airybi, airyaiprime, airybiprime)
+from sympy.testing.pytest import XFAIL
+
+from sympy.printing.julia import julia_code
+
+x, y, z = symbols('x,y,z')
+
+
+def test_Integer():
+    assert julia_code(Integer(67)) == "67"
+    assert julia_code(Integer(-1)) == "-1"
+
+
+def test_Rational():
+    assert julia_code(Rational(3, 7)) == "3 // 7"
+    assert julia_code(Rational(18, 9)) == "2"
+    assert julia_code(Rational(3, -7)) == "-3 // 7"
+    assert julia_code(Rational(-3, -7)) == "3 // 7"
+    assert julia_code(x + Rational(3, 7)) == "x + 3 // 7"
+    assert julia_code(Rational(3, 7)*x) == "(3 // 7) * x"
+
+
+def test_Relational():
+    assert julia_code(Eq(x, y)) == "x == y"
+    assert julia_code(Ne(x, y)) == "x != y"
+    assert julia_code(Le(x, y)) == "x <= y"
+    assert julia_code(Lt(x, y)) == "x < y"
+    assert julia_code(Gt(x, y)) == "x > y"
+    assert julia_code(Ge(x, y)) == "x >= y"
+
+
+def test_Function():
+    assert julia_code(sin(x) ** cos(x)) == "sin(x) .^ cos(x)"
+    assert julia_code(abs(x)) == "abs(x)"
+    assert julia_code(ceiling(x)) == "ceil(x)"
+
+
+def test_Pow():
+    assert julia_code(x**3) == "x .^ 3"
+    assert julia_code(x**(y**3)) == "x .^ (y .^ 3)"
+    assert julia_code(x**Rational(2, 3)) == 'x .^ (2 // 3)'
+    g = implemented_function('g', Lambda(x, 2*x))
+    assert julia_code(1/(g(x)*3.5)**(x - y**x)/(x**2 + y)) == \
+        "(3.5 * 2 * x) .^ (-x + y .^ x) ./ (x .^ 2 + y)"
+    # For issue 14160
+    assert julia_code(Mul(-2, x, Pow(Mul(y,y,evaluate=False), -1, evaluate=False),
+                                                evaluate=False)) == '-2 * x ./ (y .* y)'
+
+
+def test_basic_ops():
+    assert julia_code(x*y) == "x .* y"
+    assert julia_code(x + y) == "x + y"
+    assert julia_code(x - y) == "x - y"
+    assert julia_code(-x) == "-x"
+
+
+def test_1_over_x_and_sqrt():
+    # 1.0 and 0.5 would do something different in regular StrPrinter,
+    # but these are exact in IEEE floating point so no different here.
+    assert julia_code(1/x) == '1 ./ x'
+    assert julia_code(x**-1) == julia_code(x**-1.0) == '1 ./ x'
+    assert julia_code(1/sqrt(x)) == '1 ./ sqrt(x)'
+    assert julia_code(x**-S.Half) == julia_code(x**-0.5) == '1 ./ sqrt(x)'
+    assert julia_code(sqrt(x)) == 'sqrt(x)'
+    assert julia_code(x**S.Half) == julia_code(x**0.5) == 'sqrt(x)'
+    assert julia_code(1/pi) == '1 / pi'
+    assert julia_code(pi**-1) == julia_code(pi**-1.0) == '1 / pi'
+    assert julia_code(pi**-0.5) == '1 / sqrt(pi)'
+
+
+def test_mix_number_mult_symbols():
+    assert julia_code(3*x) == "3 * x"
+    assert julia_code(pi*x) == "pi * x"
+    assert julia_code(3/x) == "3 ./ x"
+    assert julia_code(pi/x) == "pi ./ x"
+    assert julia_code(x/3) == "x / 3"
+    assert julia_code(x/pi) == "x / pi"
+    assert julia_code(x*y) == "x .* y"
+    assert julia_code(3*x*y) == "3 * x .* y"
+    assert julia_code(3*pi*x*y) == "3 * pi * x .* y"
+    assert julia_code(x/y) == "x ./ y"
+    assert julia_code(3*x/y) == "3 * x ./ y"
+    assert julia_code(x*y/z) == "x .* y ./ z"
+    assert julia_code(x/y*z) == "x .* z ./ y"
+    assert julia_code(1/x/y) == "1 ./ (x .* y)"
+    assert julia_code(2*pi*x/y/z) == "2 * pi * x ./ (y .* z)"
+    assert julia_code(3*pi/x) == "3 * pi ./ x"
+    assert julia_code(S(3)/5) == "3 // 5"
+    assert julia_code(S(3)/5*x) == "(3 // 5) * x"
+    assert julia_code(x/y/z) == "x ./ (y .* z)"
+    assert julia_code((x+y)/z) == "(x + y) ./ z"
+    assert julia_code((x+y)/(z+x)) == "(x + y) ./ (x + z)"
+    assert julia_code((x+y)/EulerGamma) == "(x + y) / eulergamma"
+    assert julia_code(x/3/pi) == "x / (3 * pi)"
+    assert julia_code(S(3)/5*x*y/pi) == "(3 // 5) * x .* y / pi"
+
+
+def test_mix_number_pow_symbols():
+    assert julia_code(pi**3) == 'pi ^ 3'
+    assert julia_code(x**2) == 'x .^ 2'
+    assert julia_code(x**(pi**3)) == 'x .^ (pi ^ 3)'
+    assert julia_code(x**y) == 'x .^ y'
+    assert julia_code(x**(y**z)) == 'x .^ (y .^ z)'
+    assert julia_code((x**y)**z) == '(x .^ y) .^ z'
+
+
+def test_imag():
+    I = S('I')
+    assert julia_code(I) == "im"
+    assert julia_code(5*I) == "5im"
+    assert julia_code((S(3)/2)*I) == "(3 // 2) * im"
+    assert julia_code(3+4*I) == "3 + 4im"
+
+
+def test_constants():
+    assert julia_code(pi) == "pi"
+    assert julia_code(oo) == "Inf"
+    assert julia_code(-oo) == "-Inf"
+    assert julia_code(S.NegativeInfinity) == "-Inf"
+    assert julia_code(S.NaN) == "NaN"
+    assert julia_code(S.Exp1) == "e"
+    assert julia_code(exp(1)) == "e"
+
+
+def test_constants_other():
+    assert julia_code(2*GoldenRatio) == "2 * golden"
+    assert julia_code(2*Catalan) == "2 * catalan"
+    assert julia_code(2*EulerGamma) == "2 * eulergamma"
+
+
+def test_boolean():
+    assert julia_code(x & y) == "x && y"
+    assert julia_code(x | y) == "x || y"
+    assert julia_code(~x) == "!x"
+    assert julia_code(x & y & z) == "x && y && z"
+    assert julia_code(x | y | z) == "x || y || z"
+    assert julia_code((x & y) | z) == "z || x && y"
+    assert julia_code((x | y) & z) == "z && (x || y)"
+
+
+def test_Matrices():
+    assert julia_code(Matrix(1, 1, [10])) == "[10]"
+    A = Matrix([[1, sin(x/2), abs(x)],
+                [0, 1, pi],
+                [0, exp(1), ceiling(x)]]);
+    expected = ("[1 sin(x / 2)  abs(x);\n"
+                "0          1      pi;\n"
+                "0          e ceil(x)]")
+    assert julia_code(A) == expected
+    # row and columns
+    assert julia_code(A[:,0]) == "[1, 0, 0]"
+    assert julia_code(A[0,:]) == "[1 sin(x / 2) abs(x)]"
+    # empty matrices
+    assert julia_code(Matrix(0, 0, [])) == 'zeros(0, 0)'
+    assert julia_code(Matrix(0, 3, [])) == 'zeros(0, 3)'
+    # annoying to read but correct
+    assert julia_code(Matrix([[x, x - y, -y]])) == "[x x - y -y]"
+
+
+def test_vector_entries_hadamard():
+    # For a row or column, user might to use the other dimension
+    A = Matrix([[1, sin(2/x), 3*pi/x/5]])
+    assert julia_code(A) == "[1 sin(2 ./ x) (3 // 5) * pi ./ x]"
+    assert julia_code(A.T) == "[1, sin(2 ./ x), (3 // 5) * pi ./ x]"
+
+
+@XFAIL
+def test_Matrices_entries_not_hadamard():
+    # For Matrix with col >= 2, row >= 2, they need to be scalars
+    # FIXME: is it worth worrying about this?  Its not wrong, just
+    # leave it user's responsibility to put scalar data for x.
+    A = Matrix([[1, sin(2/x), 3*pi/x/5], [1, 2, x*y]])
+    expected = ("[1 sin(2/x) 3*pi/(5*x);\n"
+                "1        2        x*y]") # <- we give x.*y
+    assert julia_code(A) == expected
+
+
+def test_MatrixSymbol():
+    n = Symbol('n', integer=True)
+    A = MatrixSymbol('A', n, n)
+    B = MatrixSymbol('B', n, n)
+    assert julia_code(A*B) == "A * B"
+    assert julia_code(B*A) == "B * A"
+    assert julia_code(2*A*B) == "2 * A * B"
+    assert julia_code(B*2*A) == "2 * B * A"
+    assert julia_code(A*(B + 3*Identity(n))) == "A * (3 * eye(n) + B)"
+    assert julia_code(A**(x**2)) == "A ^ (x .^ 2)"
+    assert julia_code(A**3) == "A ^ 3"
+    assert julia_code(A**S.Half) == "A ^ (1 // 2)"
+
+
+def test_special_matrices():
+    assert julia_code(6*Identity(3)) == "6 * eye(3)"
+
+
+def test_containers():
+    assert julia_code([1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]) == \
+        "Any[1, 2, 3, Any[4, 5, Any[6, 7]], 8, Any[9, 10], 11]"
+    assert julia_code((1, 2, (3, 4))) == "(1, 2, (3, 4))"
+    assert julia_code([1]) == "Any[1]"
+    assert julia_code((1,)) == "(1,)"
+    assert julia_code(Tuple(*[1, 2, 3])) == "(1, 2, 3)"
+    assert julia_code((1, x*y, (3, x**2))) == "(1, x .* y, (3, x .^ 2))"
+    # scalar, matrix, empty matrix and empty list
+    assert julia_code((1, eye(3), Matrix(0, 0, []), [])) == "(1, [1 0 0;\n0 1 0;\n0 0 1], zeros(0, 0), Any[])"
+
+
+def test_julia_noninline():
+    source = julia_code((x+y)/Catalan, assign_to='me', inline=False)
+    expected = (
+        "const Catalan = %s\n"
+        "me = (x + y) / Catalan"
+    ) % Catalan.evalf(17)
+    assert source == expected
+
+
+def test_julia_piecewise():
+    expr = Piecewise((x, x < 1), (x**2, True))
+    assert julia_code(expr) == "((x < 1) ? (x) : (x .^ 2))"
+    assert julia_code(expr, assign_to="r") == (
+        "r = ((x < 1) ? (x) : (x .^ 2))")
+    assert julia_code(expr, assign_to="r", inline=False) == (
+        "if (x < 1)\n"
+        "    r = x\n"
+        "else\n"
+        "    r = x .^ 2\n"
+        "end")
+    expr = Piecewise((x**2, x < 1), (x**3, x < 2), (x**4, x < 3), (x**5, True))
+    expected = ("((x < 1) ? (x .^ 2) :\n"
+                "(x < 2) ? (x .^ 3) :\n"
+                "(x < 3) ? (x .^ 4) : (x .^ 5))")
+    assert julia_code(expr) == expected
+    assert julia_code(expr, assign_to="r") == "r = " + expected
+    assert julia_code(expr, assign_to="r", inline=False) == (
+        "if (x < 1)\n"
+        "    r = x .^ 2\n"
+        "elseif (x < 2)\n"
+        "    r = x .^ 3\n"
+        "elseif (x < 3)\n"
+        "    r = x .^ 4\n"
+        "else\n"
+        "    r = x .^ 5\n"
+        "end")
+    # Check that Piecewise without a True (default) condition error
+    expr = Piecewise((x, x < 1), (x**2, x > 1), (sin(x), x > 0))
+    raises(ValueError, lambda: julia_code(expr))
+
+
+def test_julia_piecewise_times_const():
+    pw = Piecewise((x, x < 1), (x**2, True))
+    assert julia_code(2*pw) == "2 * ((x < 1) ? (x) : (x .^ 2))"
+    assert julia_code(pw/x) == "((x < 1) ? (x) : (x .^ 2)) ./ x"
+    assert julia_code(pw/(x*y)) == "((x < 1) ? (x) : (x .^ 2)) ./ (x .* y)"
+    assert julia_code(pw/3) == "((x < 1) ? (x) : (x .^ 2)) / 3"
+
+
+def test_julia_matrix_assign_to():
+    A = Matrix([[1, 2, 3]])
+    assert julia_code(A, assign_to='a') == "a = [1 2 3]"
+    A = Matrix([[1, 2], [3, 4]])
+    assert julia_code(A, assign_to='A') == "A = [1 2;\n3 4]"
+
+
+def test_julia_matrix_assign_to_more():
+    # assigning to Symbol or MatrixSymbol requires lhs/rhs match
+    A = Matrix([[1, 2, 3]])
+    B = MatrixSymbol('B', 1, 3)
+    C = MatrixSymbol('C', 2, 3)
+    assert julia_code(A, assign_to=B) == "B = [1 2 3]"
+    raises(ValueError, lambda: julia_code(A, assign_to=x))
+    raises(ValueError, lambda: julia_code(A, assign_to=C))
+
+
+def test_julia_matrix_1x1():
+    A = Matrix([[3]])
+    B = MatrixSymbol('B', 1, 1)
+    C = MatrixSymbol('C', 1, 2)
+    assert julia_code(A, assign_to=B) == "B = [3]"
+    # FIXME?
+    #assert julia_code(A, assign_to=x) == "x = [3]"
+    raises(ValueError, lambda: julia_code(A, assign_to=C))
+
+
+def test_julia_matrix_elements():
+    A = Matrix([[x, 2, x*y]])
+    assert julia_code(A[0, 0]**2 + A[0, 1] + A[0, 2]) == "x .^ 2 + x .* y + 2"
+    A = MatrixSymbol('AA', 1, 3)
+    assert julia_code(A) == "AA"
+    assert julia_code(A[0, 0]**2 + sin(A[0,1]) + A[0,2]) == \
+           "sin(AA[1,2]) + AA[1,1] .^ 2 + AA[1,3]"
+    assert julia_code(sum(A)) == "AA[1,1] + AA[1,2] + AA[1,3]"
+
+
+def test_julia_boolean():
+    assert julia_code(True) == "true"
+    assert julia_code(S.true) == "true"
+    assert julia_code(False) == "false"
+    assert julia_code(S.false) == "false"
+
+
+def test_julia_not_supported():
+    assert julia_code(S.ComplexInfinity) == (
+        "# Not supported in Julia:\n"
+        "# ComplexInfinity\n"
+        "zoo"
+    )
+    f = Function('f')
+    assert julia_code(f(x).diff(x)) == (
+        "# Not supported in Julia:\n"
+        "# Derivative\n"
+        "Derivative(f(x), x)"
+    )
+
+
+def test_trick_indent_with_end_else_words():
+    # words starting with "end" or "else" do not confuse the indenter
+    t1 = S('endless');
+    t2 = S('elsewhere');
+    pw = Piecewise((t1, x < 0), (t2, x <= 1), (1, True))
+    assert julia_code(pw, inline=False) == (
+        "if (x < 0)\n"
+        "    endless\n"
+        "elseif (x <= 1)\n"
+        "    elsewhere\n"
+        "else\n"
+        "    1\n"
+        "end")
+
+
+def test_haramard():
+    A = MatrixSymbol('A', 3, 3)
+    B = MatrixSymbol('B', 3, 3)
+    v = MatrixSymbol('v', 3, 1)
+    h = MatrixSymbol('h', 1, 3)
+    C = HadamardProduct(A, B)
+    assert julia_code(C) == "A .* B"
+    assert julia_code(C*v) == "(A .* B) * v"
+    assert julia_code(h*C*v) == "h * (A .* B) * v"
+    assert julia_code(C*A) == "(A .* B) * A"
+    # mixing Hadamard and scalar strange b/c we vectorize scalars
+    assert julia_code(C*x*y) == "(x .* y) * (A .* B)"
+
+
+def test_sparse():
+    M = SparseMatrix(5, 6, {})
+    M[2, 2] = 10;
+    M[1, 2] = 20;
+    M[1, 3] = 22;
+    M[0, 3] = 30;
+    M[3, 0] = x*y;
+    assert julia_code(M) == (
+        "sparse([4, 2, 3, 1, 2], [1, 3, 3, 4, 4], [x .* y, 20, 10, 30, 22], 5, 6)"
+    )
+
+
+def test_specfun():
+    n = Symbol('n')
+    for f in [besselj, bessely, besseli, besselk]:
+        assert julia_code(f(n, x)) == f.__name__ + '(n, x)'
+    for f in [airyai, airyaiprime, airybi, airybiprime]:
+        assert julia_code(f(x)) == f.__name__ + '(x)'
+    assert julia_code(hankel1(n, x)) == 'hankelh1(n, x)'
+    assert julia_code(hankel2(n, x)) == 'hankelh2(n, x)'
+    assert julia_code(jn(n, x)) == 'sqrt(2) * sqrt(pi) * sqrt(1 ./ x) .* besselj(n + 1 // 2, x) / 2'
+    assert julia_code(yn(n, x)) == 'sqrt(2) * sqrt(pi) * sqrt(1 ./ x) .* bessely(n + 1 // 2, x) / 2'
+
+
+def test_MatrixElement_printing():
+    # test cases for issue #11821
+    A = MatrixSymbol("A", 1, 3)
+    B = MatrixSymbol("B", 1, 3)
+    C = MatrixSymbol("C", 1, 3)
+
+    assert(julia_code(A[0, 0]) == "A[1,1]")
+    assert(julia_code(3 * A[0, 0]) == "3 * A[1,1]")
+
+    F = C[0, 0].subs(C, A - B)
+    assert(julia_code(F) == "(A - B)[1,1]")

env-llmeval/lib/python3.10/site-packages/sympy/printing/tests/test_lambdarepr.py

@@ -0,0 +1,246 @@
+from sympy.concrete.summations import Sum
+from sympy.core.expr import Expr
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import sin
+from sympy.matrices.dense import MutableDenseMatrix as Matrix
+from sympy.sets.sets import Interval
+from sympy.utilities.lambdify import lambdify
+from sympy.testing.pytest import raises
+
+from sympy.printing.tensorflow import TensorflowPrinter
+from sympy.printing.lambdarepr import lambdarepr, LambdaPrinter, NumExprPrinter
+
+
+x, y, z = symbols("x,y,z")
+i, a, b = symbols("i,a,b")
+j, c, d = symbols("j,c,d")
+
+
+def test_basic():
+    assert lambdarepr(x*y) == "x*y"
+    assert lambdarepr(x + y) in ["y + x", "x + y"]
+    assert lambdarepr(x**y) == "x**y"
+
+
+def test_matrix():
+    # Test printing a Matrix that has an element that is printed differently
+    # with the LambdaPrinter than with the StrPrinter.
+    e = x % 2
+    assert lambdarepr(e) != str(e)
+    assert lambdarepr(Matrix([e])) == 'ImmutableDenseMatrix([[x % 2]])'
+
+
+def test_piecewise():
+    # In each case, test eval() the lambdarepr() to make sure there are a
+    # correct number of parentheses. It will give a SyntaxError if there aren't.
+
+    h = "lambda x: "
+
+    p = Piecewise((x, x < 0))
+    l = lambdarepr(p)
+    eval(h + l)
+    assert l == "((x) if (x < 0) else None)"
+
+    p = Piecewise(
+        (1, x < 1),
+        (2, x < 2),
+        (0, True)
+    )
+    l = lambdarepr(p)
+    eval(h + l)
+    assert l == "((1) if (x < 1) else (2) if (x < 2) else (0))"
+
+    p = Piecewise(
+        (1, x < 1),
+        (2, x < 2),
+    )
+    l = lambdarepr(p)
+    eval(h + l)
+    assert l == "((1) if (x < 1) else (2) if (x < 2) else None)"
+
+    p = Piecewise(
+        (x, x < 1),
+        (x**2, Interval(3, 4, True, False).contains(x)),
+        (0, True),
+    )
+    l = lambdarepr(p)
+    eval(h + l)
+    assert l == "((x) if (x < 1) else (x**2) if (((x <= 4)) and ((x > 3))) else (0))"
+
+    p = Piecewise(
+        (x**2, x < 0),
+        (x, x < 1),
+        (2 - x, x >= 1),
+        (0, True), evaluate=False
+    )
+    l = lambdarepr(p)
+    eval(h + l)
+    assert l == "((x**2) if (x < 0) else (x) if (x < 1)"\
+                                " else (2 - x) if (x >= 1) else (0))"
+
+    p = Piecewise(
+        (x**2, x < 0),
+        (x, x < 1),
+        (2 - x, x >= 1), evaluate=False
+    )
+    l = lambdarepr(p)
+    eval(h + l)
+    assert l == "((x**2) if (x < 0) else (x) if (x < 1)"\
+                    " else (2 - x) if (x >= 1) else None)"
+
+    p = Piecewise(
+        (1, x >= 1),
+        (2, x >= 2),
+        (3, x >= 3),
+        (4, x >= 4),
+        (5, x >= 5),
+        (6, True)
+    )
+    l = lambdarepr(p)
+    eval(h + l)
+    assert l == "((1) if (x >= 1) else (2) if (x >= 2) else (3) if (x >= 3)"\
+                        " else (4) if (x >= 4) else (5) if (x >= 5) else (6))"
+
+    p = Piecewise(
+        (1, x <= 1),
+        (2, x <= 2),
+        (3, x <= 3),
+        (4, x <= 4),
+        (5, x <= 5),
+        (6, True)
+    )
+    l = lambdarepr(p)
+    eval(h + l)
+    assert l == "((1) if (x <= 1) else (2) if (x <= 2) else (3) if (x <= 3)"\
+                            " else (4) if (x <= 4) else (5) if (x <= 5) else (6))"
+
+    p = Piecewise(
+        (1, x > 1),
+        (2, x > 2),
+        (3, x > 3),
+        (4, x > 4),
+        (5, x > 5),
+        (6, True)
+    )
+    l = lambdarepr(p)
+    eval(h + l)
+    assert l =="((1) if (x > 1) else (2) if (x > 2) else (3) if (x > 3)"\
+                            " else (4) if (x > 4) else (5) if (x > 5) else (6))"
+
+    p = Piecewise(
+        (1, x < 1),
+        (2, x < 2),
+        (3, x < 3),
+        (4, x < 4),
+        (5, x < 5),
+        (6, True)
+    )
+    l = lambdarepr(p)
+    eval(h + l)
+    assert l == "((1) if (x < 1) else (2) if (x < 2) else (3) if (x < 3)"\
+                            " else (4) if (x < 4) else (5) if (x < 5) else (6))"
+
+    p = Piecewise(
+        (Piecewise(
+            (1, x > 0),
+            (2, True)
+        ), y > 0),
+        (3, True)
+    )
+    l = lambdarepr(p)
+    eval(h + l)
+    assert l == "((((1) if (x > 0) else (2))) if (y > 0) else (3))"
+
+
+def test_sum__1():
+    # In each case, test eval() the lambdarepr() to make sure that
+    # it evaluates to the same results as the symbolic expression
+    s = Sum(x ** i, (i, a, b))
+    l = lambdarepr(s)
+    assert l == "(builtins.sum(x**i for i in range(a, b+1)))"
+
+    args = x, a, b
+    f = lambdify(args, s)
+    v = 2, 3, 8
+    assert f(*v) == s.subs(zip(args, v)).doit()
+
+def test_sum__2():
+    s = Sum(i * x, (i, a, b))
+    l = lambdarepr(s)
+    assert l == "(builtins.sum(i*x for i in range(a, b+1)))"
+
+    args = x, a, b
+    f = lambdify(args, s)
+    v = 2, 3, 8
+    assert f(*v) == s.subs(zip(args, v)).doit()
+
+
+def test_multiple_sums():
+    s = Sum(i * x + j, (i, a, b), (j, c, d))
+
+    l = lambdarepr(s)
+    assert l == "(builtins.sum(i*x + j for i in range(a, b+1) for j in range(c, d+1)))"
+
+    args = x, a, b, c, d
+    f = lambdify(args, s)
+    vals = 2, 3, 4, 5, 6
+    f_ref = s.subs(zip(args, vals)).doit()
+    f_res = f(*vals)
+    assert f_res == f_ref
+
+
+def test_sqrt():
+    prntr = LambdaPrinter({'standard' : 'python3'})
+    assert prntr._print_Pow(sqrt(x), rational=False) == 'sqrt(x)'
+    assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1/2)'
+
+
+def test_settings():
+    raises(TypeError, lambda: lambdarepr(sin(x), method="garbage"))
+
+
+def test_numexpr():
+    # test ITE rewrite as Piecewise
+    from sympy.logic.boolalg import ITE
+    expr = ITE(x > 0, True, False, evaluate=False)
+    assert NumExprPrinter().doprint(expr) == \
+           "numexpr.evaluate('where((x > 0), True, False)', truediv=True)"
+
+    from sympy.codegen.ast import Return, FunctionDefinition, Variable, Assignment
+    func_def = FunctionDefinition(None, 'foo', [Variable(x)], [Assignment(y,x), Return(y**2)])
+    expected = "def foo(x):\n"\
+               "    y = numexpr.evaluate('x', truediv=True)\n"\
+               "    return numexpr.evaluate('y**2', truediv=True)"
+    assert NumExprPrinter().doprint(func_def) == expected
+
+
+class CustomPrintedObject(Expr):
+    def _lambdacode(self, printer):
+        return 'lambda'
+
+    def _tensorflowcode(self, printer):
+        return 'tensorflow'
+
+    def _numpycode(self, printer):
+        return 'numpy'
+
+    def _numexprcode(self, printer):
+        return 'numexpr'
+
+    def _mpmathcode(self, printer):
+        return 'mpmath'
+
+
+def test_printmethod():
+    # In each case, printmethod is called to test
+    # its working
+
+    obj = CustomPrintedObject()
+    assert LambdaPrinter().doprint(obj) == 'lambda'
+    assert TensorflowPrinter().doprint(obj) == 'tensorflow'
+    assert NumExprPrinter().doprint(obj) == "numexpr.evaluate('numexpr', truediv=True)"
+
+    assert NumExprPrinter().doprint(Piecewise((y, x >= 0), (z, x < 0))) == \
+            "numexpr.evaluate('where((x >= 0), y, z)', truediv=True)"