Add files using upload-large-folder tool

llmeval-env/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',
+]

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

@@ -0,0 +1,539 @@
+from __future__ import annotations
+from typing import Any
+
+from sympy.external import import_module
+from sympy.printing.printer import Printer
+from sympy.utilities.iterables import is_sequence
+import sympy
+from functools import partial
+
+
+aesara = import_module('aesara')
+
+if aesara:
+    aes = aesara.scalar
+    aet = aesara.tensor
+    from aesara.tensor import nlinalg
+    from aesara.tensor.elemwise import Elemwise
+    from aesara.tensor.elemwise import DimShuffle
+
+    # `true_divide` replaced `true_div` in Aesara 2.8.11 (released 2023) to
+    # match NumPy
+    # XXX: Remove this when not needed to support older versions.
+    true_divide = getattr(aet, 'true_divide', None)
+    if true_divide is None:
+        true_divide = aet.true_div
+
+    mapping = {
+            sympy.Add: aet.add,
+            sympy.Mul: aet.mul,
+            sympy.Abs: aet.abs,
+            sympy.sign: aet.sgn,
+            sympy.ceiling: aet.ceil,
+            sympy.floor: aet.floor,
+            sympy.log: aet.log,
+            sympy.exp: aet.exp,
+            sympy.sqrt: aet.sqrt,
+            sympy.cos: aet.cos,
+            sympy.acos: aet.arccos,
+            sympy.sin: aet.sin,
+            sympy.asin: aet.arcsin,
+            sympy.tan: aet.tan,
+            sympy.atan: aet.arctan,
+            sympy.atan2: aet.arctan2,
+            sympy.cosh: aet.cosh,
+            sympy.acosh: aet.arccosh,
+            sympy.sinh: aet.sinh,
+            sympy.asinh: aet.arcsinh,
+            sympy.tanh: aet.tanh,
+            sympy.atanh: aet.arctanh,
+            sympy.re: aet.real,
+            sympy.im: aet.imag,
+            sympy.arg: aet.angle,
+            sympy.erf: aet.erf,
+            sympy.gamma: aet.gamma,
+            sympy.loggamma: aet.gammaln,
+            sympy.Pow: aet.pow,
+            sympy.Eq: aet.eq,
+            sympy.StrictGreaterThan: aet.gt,
+            sympy.StrictLessThan: aet.lt,
+            sympy.LessThan: aet.le,
+            sympy.GreaterThan: aet.ge,
+            sympy.And: aet.bitwise_and,  # bitwise
+            sympy.Or: aet.bitwise_or,  # bitwise
+            sympy.Not: aet.invert,  # bitwise
+            sympy.Xor: aet.bitwise_xor,  # bitwise
+            sympy.Max: aet.maximum,  # Sympy accept >2 inputs, Aesara only 2
+            sympy.Min: aet.minimum,  # Sympy accept >2 inputs, Aesara only 2
+            sympy.conjugate: aet.conj,
+            sympy.core.numbers.ImaginaryUnit: lambda:aet.complex(0,1),
+            # Matrices
+            sympy.MatAdd: Elemwise(aes.add),
+            sympy.HadamardProduct: Elemwise(aes.mul),
+            sympy.Trace: nlinalg.trace,
+            sympy.Determinant : nlinalg.det,
+            sympy.Inverse: nlinalg.matrix_inverse,
+            sympy.Transpose: DimShuffle((False, False), [1, 0]),
+    }
+
+
+class AesaraPrinter(Printer):
+    """ Code printer which creates Aesara symbolic expression graphs.
+
+    Parameters
+    ==========
+
+    cache : dict
+        Cache dictionary to use. If None (default) will use
+        the global cache. To create a printer which does not depend on or alter
+        global state pass an empty dictionary. Note: the dictionary is not
+        copied on initialization of the printer and will be updated in-place,
+        so using the same dict object when creating multiple printers or making
+        multiple calls to :func:`.aesara_code` or :func:`.aesara_function` means
+        the cache is shared between all these applications.
+
+    Attributes
+    ==========
+
+    cache : dict
+        A cache of Aesara variables which have been created for SymPy
+        symbol-like objects (e.g. :class:`sympy.core.symbol.Symbol` or
+        :class:`sympy.matrices.expressions.MatrixSymbol`). This is used to
+        ensure that all references to a given symbol in an expression (or
+        multiple expressions) are printed as the same Aesara variable, which is
+        created only once. Symbols are differentiated only by name and type. The
+        format of the cache's contents should be considered opaque to the user.
+    """
+    printmethod = "_aesara"
+
+    def __init__(self, *args, **kwargs):
+        self.cache = kwargs.pop('cache', {})
+        super().__init__(*args, **kwargs)
+
+    def _get_key(self, s, name=None, dtype=None, broadcastable=None):
+        """ Get the cache key for a SymPy object.
+
+        Parameters
+        ==========
+
+        s : sympy.core.basic.Basic
+            SymPy object to get key for.
+
+        name : str
+            Name of object, if it does not have a ``name`` attribute.
+        """
+
+        if name is None:
+            name = s.name
+
+        return (name, type(s), s.args, dtype, broadcastable)
+
+    def _get_or_create(self, s, name=None, dtype=None, broadcastable=None):
+        """
+        Get the Aesara variable for a SymPy symbol from the cache, or create it
+        if it does not exist.
+        """
+
+        # Defaults
+        if name is None:
+            name = s.name
+        if dtype is None:
+            dtype = 'floatX'
+        if broadcastable is None:
+            broadcastable = ()
+
+        key = self._get_key(s, name, dtype=dtype, broadcastable=broadcastable)
+
+        if key in self.cache:
+            return self.cache[key]
+
+        value = aet.tensor(name=name, dtype=dtype, broadcastable=broadcastable)
+        self.cache[key] = value
+        return value
+
+    def _print_Symbol(self, s, **kwargs):
+        dtype = kwargs.get('dtypes', {}).get(s)
+        bc = kwargs.get('broadcastables', {}).get(s)
+        return self._get_or_create(s, dtype=dtype, broadcastable=bc)
+
+    def _print_AppliedUndef(self, s, **kwargs):
+        name = str(type(s)) + '_' + str(s.args[0])
+        dtype = kwargs.get('dtypes', {}).get(s)
+        bc = kwargs.get('broadcastables', {}).get(s)
+        return self._get_or_create(s, name=name, dtype=dtype, broadcastable=bc)
+
+    def _print_Basic(self, expr, **kwargs):
+        op = mapping[type(expr)]
+        children = [self._print(arg, **kwargs) for arg in expr.args]
+        return op(*children)
+
+    def _print_Number(self, n, **kwargs):
+        # Integers already taken care of below, interpret as float
+        return float(n.evalf())
+
+    def _print_MatrixSymbol(self, X, **kwargs):
+        dtype = kwargs.get('dtypes', {}).get(X)
+        return self._get_or_create(X, dtype=dtype, broadcastable=(None, None))
+
+    def _print_DenseMatrix(self, X, **kwargs):
+        if not hasattr(aet, 'stacklists'):
+            raise NotImplementedError(
+               "Matrix translation not yet supported in this version of Aesara")
+
+        return aet.stacklists([
+            [self._print(arg, **kwargs) for arg in L]
+            for L in X.tolist()
+        ])
+
+    _print_ImmutableMatrix = _print_ImmutableDenseMatrix = _print_DenseMatrix
+
+    def _print_MatMul(self, expr, **kwargs):
+        children = [self._print(arg, **kwargs) for arg in expr.args]
+        result = children[0]
+        for child in children[1:]:
+            result = aet.dot(result, child)
+        return result
+
+    def _print_MatPow(self, expr, **kwargs):
+        children = [self._print(arg, **kwargs) for arg in expr.args]
+        result = 1
+        if isinstance(children[1], int) and children[1] > 0:
+            for i in range(children[1]):
+                result = aet.dot(result, children[0])
+        else:
+            raise NotImplementedError('''Only non-negative integer
+           powers of matrices can be handled by Aesara at the moment''')
+        return result
+
+    def _print_MatrixSlice(self, expr, **kwargs):
+        parent = self._print(expr.parent, **kwargs)
+        rowslice = self._print(slice(*expr.rowslice), **kwargs)
+        colslice = self._print(slice(*expr.colslice), **kwargs)
+        return parent[rowslice, colslice]
+
+    def _print_BlockMatrix(self, expr, **kwargs):
+        nrows, ncols = expr.blocks.shape
+        blocks = [[self._print(expr.blocks[r, c], **kwargs)
+                        for c in range(ncols)]
+                        for r in range(nrows)]
+        return aet.join(0, *[aet.join(1, *row) for row in blocks])
+
+
+    def _print_slice(self, expr, **kwargs):
+        return slice(*[self._print(i, **kwargs)
+                        if isinstance(i, sympy.Basic) else i
+                        for i in (expr.start, expr.stop, expr.step)])
+
+    def _print_Pi(self, expr, **kwargs):
+        return 3.141592653589793
+
+    def _print_Piecewise(self, expr, **kwargs):
+        import numpy as np
+        e, cond = expr.args[0].args  # First condition and corresponding value
+
+        # Print conditional expression and value for first condition
+        p_cond = self._print(cond, **kwargs)
+        p_e = self._print(e, **kwargs)
+
+        # One condition only
+        if len(expr.args) == 1:
+            # Return value if condition else NaN
+            return aet.switch(p_cond, p_e, np.nan)
+
+        # Return value_1 if condition_1 else evaluate remaining conditions
+        p_remaining = self._print(sympy.Piecewise(*expr.args[1:]), **kwargs)
+        return aet.switch(p_cond, p_e, p_remaining)
+
+    def _print_Rational(self, expr, **kwargs):
+        return true_divide(self._print(expr.p, **kwargs),
+                           self._print(expr.q, **kwargs))
+
+    def _print_Integer(self, expr, **kwargs):
+        return expr.p
+
+    def _print_factorial(self, expr, **kwargs):
+        return self._print(sympy.gamma(expr.args[0] + 1), **kwargs)
+
+    def _print_Derivative(self, deriv, **kwargs):
+        from aesara.gradient import Rop
+
+        rv = self._print(deriv.expr, **kwargs)
+        for var in deriv.variables:
+            var = self._print(var, **kwargs)
+            rv = Rop(rv, var, aet.ones_like(var))
+        return rv
+
+    def emptyPrinter(self, expr):
+        return expr
+
+    def doprint(self, expr, dtypes=None, broadcastables=None):
+        """ Convert a SymPy expression to a Aesara graph variable.
+
+        The ``dtypes`` and ``broadcastables`` arguments are used to specify the
+        data type, dimension, and broadcasting behavior of the Aesara variables
+        corresponding to the free symbols in ``expr``. Each is a mapping from
+        SymPy symbols to the value of the corresponding argument to
+        ``aesara.tensor.var.TensorVariable``.
+
+        See the corresponding `documentation page`__ for more information on
+        broadcasting in Aesara.
+
+        .. __: https://aesara.readthedocs.io/en/latest/tutorial/broadcasting.html
+
+        Parameters
+        ==========
+
+        expr : sympy.core.expr.Expr
+            SymPy expression to print.
+
+        dtypes : dict
+            Mapping from SymPy symbols to Aesara datatypes to use when creating
+            new Aesara variables for those symbols. Corresponds to the ``dtype``
+            argument to ``aesara.tensor.var.TensorVariable``. Defaults to ``'floatX'``
+            for symbols not included in the mapping.
+
+        broadcastables : dict
+            Mapping from SymPy symbols to the value of the ``broadcastable``
+            argument to ``aesara.tensor.var.TensorVariable`` to use when creating Aesara
+            variables for those symbols. Defaults to the empty tuple for symbols
+            not included in the mapping (resulting in a scalar).
+
+        Returns
+        =======
+
+        aesara.graph.basic.Variable
+            A variable corresponding to the expression's value in a Aesara
+            symbolic expression graph.
+
+        """
+        if dtypes is None:
+            dtypes = {}
+        if broadcastables is None:
+            broadcastables = {}
+
+        return self._print(expr, dtypes=dtypes, broadcastables=broadcastables)
+
+
+global_cache: dict[Any, Any] = {}
+
+
+def aesara_code(expr, cache=None, **kwargs):
+    """
+    Convert a SymPy expression into a Aesara graph variable.
+
+    Parameters
+    ==========
+
+    expr : sympy.core.expr.Expr
+        SymPy expression object to convert.
+
+    cache : dict
+        Cached Aesara variables (see :class:`AesaraPrinter.cache
+        <AesaraPrinter>`). Defaults to the module-level global cache.
+
+    dtypes : dict
+        Passed to :meth:`.AesaraPrinter.doprint`.
+
+    broadcastables : dict
+        Passed to :meth:`.AesaraPrinter.doprint`.
+
+    Returns
+    =======
+
+    aesara.graph.basic.Variable
+        A variable corresponding to the expression's value in a Aesara symbolic
+        expression graph.
+
+    """
+    if not aesara:
+        raise ImportError("aesara is required for aesara_code")
+
+    if cache is None:
+        cache = global_cache
+
+    return AesaraPrinter(cache=cache, settings={}).doprint(expr, **kwargs)
+
+
+def dim_handling(inputs, dim=None, dims=None, broadcastables=None):
+    r"""
+    Get value of ``broadcastables`` argument to :func:`.aesara_code` from
+    keyword arguments to :func:`.aesara_function`.
+
+    Included for backwards compatibility.
+
+    Parameters
+    ==========
+
+    inputs
+        Sequence of input symbols.
+
+    dim : int
+        Common number of dimensions for all inputs. Overrides other arguments
+        if given.
+
+    dims : dict
+        Mapping from input symbols to number of dimensions. Overrides
+        ``broadcastables`` argument if given.
+
+    broadcastables : dict
+        Explicit value of ``broadcastables`` argument to
+        :meth:`.AesaraPrinter.doprint`. If not None function will return this value unchanged.
+
+    Returns
+    =======
+    dict
+        Dictionary mapping elements of ``inputs`` to their "broadcastable"
+        values (tuple of ``bool``\ s).
+    """
+    if dim is not None:
+        return {s: (False,) * dim for s in inputs}
+
+    if dims is not None:
+        maxdim = max(dims.values())
+        return {
+            s: (False,) * d + (True,) * (maxdim - d)
+            for s, d in dims.items()
+        }
+
+    if broadcastables is not None:
+        return broadcastables
+
+    return {}
+
+
+def aesara_function(inputs, outputs, scalar=False, *,
+        dim=None, dims=None, broadcastables=None, **kwargs):
+    """
+    Create a Aesara function from SymPy expressions.
+
+    The inputs and outputs are converted to Aesara variables using
+    :func:`.aesara_code` and then passed to ``aesara.function``.
+
+    Parameters
+    ==========
+
+    inputs
+        Sequence of symbols which constitute the inputs of the function.
+
+    outputs
+        Sequence of expressions which constitute the outputs(s) of the
+        function. The free symbols of each expression must be a subset of
+        ``inputs``.
+
+    scalar : bool
+        Convert 0-dimensional arrays in output to scalars. This will return a
+        Python wrapper function around the Aesara function object.
+
+    cache : dict
+        Cached Aesara variables (see :class:`AesaraPrinter.cache
+        <AesaraPrinter>`). Defaults to the module-level global cache.
+
+    dtypes : dict
+        Passed to :meth:`.AesaraPrinter.doprint`.
+
+    broadcastables : dict
+        Passed to :meth:`.AesaraPrinter.doprint`.
+
+    dims : dict
+        Alternative to ``broadcastables`` argument. Mapping from elements of
+        ``inputs`` to integers indicating the dimension of their associated
+        arrays/tensors. Overrides ``broadcastables`` argument if given.
+
+    dim : int
+        Another alternative to the ``broadcastables`` argument. Common number of
+        dimensions to use for all arrays/tensors.
+        ``aesara_function([x, y], [...], dim=2)`` is equivalent to using
+        ``broadcastables={x: (False, False), y: (False, False)}``.
+
+    Returns
+    =======
+    callable
+        A callable object which takes values of ``inputs`` as positional
+        arguments and returns an output array for each of the expressions
+        in ``outputs``. If ``outputs`` is a single expression the function will
+        return a Numpy array, if it is a list of multiple expressions the
+        function will return a list of arrays. See description of the ``squeeze``
+        argument above for the behavior when a single output is passed in a list.
+        The returned object will either be an instance of
+        ``aesara.compile.function.types.Function`` or a Python wrapper
+        function around one. In both cases, the returned value will have a
+        ``aesara_function`` attribute which points to the return value of
+        ``aesara.function``.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.printing.aesaracode import aesara_function
+
+    A simple function with one input and one output:
+
+    >>> f1 = aesara_function([x], [x**2 - 1], scalar=True)
+    >>> f1(3)
+    8.0
+
+    A function with multiple inputs and one output:
+
+    >>> f2 = aesara_function([x, y, z], [(x**z + y**z)**(1/z)], scalar=True)
+    >>> f2(3, 4, 2)
+    5.0
+
+    A function with multiple inputs and multiple outputs:
+
+    >>> f3 = aesara_function([x, y], [x**2 + y**2, x**2 - y**2], scalar=True)
+    >>> f3(2, 3)
+    [13.0, -5.0]
+
+    See also
+    ========
+
+    dim_handling
+
+    """
+    if not aesara:
+        raise ImportError("Aesara is required for aesara_function")
+
+    # Pop off non-aesara keyword args
+    cache = kwargs.pop('cache', {})
+    dtypes = kwargs.pop('dtypes', {})
+
+    broadcastables = dim_handling(
+        inputs, dim=dim, dims=dims, broadcastables=broadcastables,
+    )
+
+    # Print inputs/outputs
+    code = partial(aesara_code, cache=cache, dtypes=dtypes,
+                   broadcastables=broadcastables)
+    tinputs = list(map(code, inputs))
+    toutputs = list(map(code, outputs))
+
+    #fix constant expressions as variables
+    toutputs = [output if isinstance(output, aesara.graph.basic.Variable) else aet.as_tensor_variable(output) for output in toutputs]
+
+    if len(toutputs) == 1:
+        toutputs = toutputs[0]
+
+    # Compile aesara func
+    func = aesara.function(tinputs, toutputs, **kwargs)
+
+    is_0d = [len(o.variable.broadcastable) == 0 for o in func.outputs]
+
+    # No wrapper required
+    if not scalar or not any(is_0d):
+        func.aesara_function = func
+        return func
+
+    # Create wrapper to convert 0-dimensional outputs to scalars
+    def wrapper(*args):
+        out = func(*args)
+        # out can be array(1.0) or [array(1.0), array(2.0)]
+
+        if is_sequence(out):
+            return [o[()] if is_0d[i] else o for i, o in enumerate(out)]
+        else:
+            return out[()]
+
+    wrapper.__wrapped__ = func
+    wrapper.__doc__ = func.__doc__
+    wrapper.aesara_function = func
+    return wrapper

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

@@ -0,0 +1,747 @@
+"""
+C code printer
+
+The C89CodePrinter & C99CodePrinter converts single SymPy expressions into
+single C expressions, using the functions defined in math.h where possible.
+
+A complete code generator, which uses ccode extensively, can be found in
+sympy.utilities.codegen. The codegen module can be used to generate complete
+source code files that are compilable without further modifications.
+
+
+"""
+
+from __future__ import annotations
+from typing import Any
+
+from functools import wraps
+from itertools import chain
+
+from sympy.core import S
+from sympy.core.numbers import equal_valued
+from sympy.codegen.ast import (
+    Assignment, Pointer, Variable, Declaration, Type,
+    real, complex_, integer, bool_, float32, float64, float80,
+    complex64, complex128, intc, value_const, pointer_const,
+    int8, int16, int32, int64, uint8, uint16, uint32, uint64, untyped,
+    none
+)
+from sympy.printing.codeprinter import CodePrinter, requires
+from sympy.printing.precedence import precedence, PRECEDENCE
+from sympy.sets.fancysets import Range
+
+# 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 ccode, print_ccode # noqa:F401
+
+# dictionary mapping SymPy function to (argument_conditions, C_function).
+# Used in C89CodePrinter._print_Function(self)
+known_functions_C89 = {
+    "Abs": [(lambda x: not x.is_integer, "fabs"), (lambda x: x.is_integer, "abs")],
+    "sin": "sin",
+    "cos": "cos",
+    "tan": "tan",
+    "asin": "asin",
+    "acos": "acos",
+    "atan": "atan",
+    "atan2": "atan2",
+    "exp": "exp",
+    "log": "log",
+    "sinh": "sinh",
+    "cosh": "cosh",
+    "tanh": "tanh",
+    "floor": "floor",
+    "ceiling": "ceil",
+    "sqrt": "sqrt", # To enable automatic rewrites
+}
+
+known_functions_C99 = dict(known_functions_C89, **{
+    'exp2': 'exp2',
+    'expm1': 'expm1',
+    'log10': 'log10',
+    'log2': 'log2',
+    'log1p': 'log1p',
+    'Cbrt': 'cbrt',
+    'hypot': 'hypot',
+    'fma': 'fma',
+    'loggamma': 'lgamma',
+    'erfc': 'erfc',
+    'Max': 'fmax',
+    'Min': 'fmin',
+    "asinh": "asinh",
+    "acosh": "acosh",
+    "atanh": "atanh",
+    "erf": "erf",
+    "gamma": "tgamma",
+})
+
+# These are the core reserved words in the C language. Taken from:
+# https://en.cppreference.com/w/c/keyword
+
+reserved_words = [
+    'auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do',
+    'double', 'else', 'enum', 'extern', 'float', 'for', 'goto', 'if', 'int',
+    'long', 'register', 'return', 'short', 'signed', 'sizeof', 'static',
+    'struct', 'entry',  # never standardized, we'll leave it here anyway
+    'switch', 'typedef', 'union', 'unsigned', 'void', 'volatile', 'while'
+]
+
+reserved_words_c99 = ['inline', 'restrict']
+
+def get_math_macros():
+    """ Returns a dictionary with math-related macros from math.h/cmath
+
+    Note that these macros are not strictly required by the C/C++-standard.
+    For MSVC they are enabled by defining "_USE_MATH_DEFINES" (preferably
+    via a compilation flag).
+
+    Returns
+    =======
+
+    Dictionary mapping SymPy expressions to strings (macro names)
+
+    """
+    from sympy.codegen.cfunctions import log2, Sqrt
+    from sympy.functions.elementary.exponential import log
+    from sympy.functions.elementary.miscellaneous import sqrt
+
+    return {
+        S.Exp1: 'M_E',
+        log2(S.Exp1): 'M_LOG2E',
+        1/log(2): 'M_LOG2E',
+        log(2): 'M_LN2',
+        log(10): 'M_LN10',
+        S.Pi: 'M_PI',
+        S.Pi/2: 'M_PI_2',
+        S.Pi/4: 'M_PI_4',
+        1/S.Pi: 'M_1_PI',
+        2/S.Pi: 'M_2_PI',
+        2/sqrt(S.Pi): 'M_2_SQRTPI',
+        2/Sqrt(S.Pi): 'M_2_SQRTPI',
+        sqrt(2): 'M_SQRT2',
+        Sqrt(2): 'M_SQRT2',
+        1/sqrt(2): 'M_SQRT1_2',
+        1/Sqrt(2): 'M_SQRT1_2'
+    }
+
+
+def _as_macro_if_defined(meth):
+    """ Decorator for printer methods
+
+    When a Printer's method is decorated using this decorator the expressions printed
+    will first be looked for in the attribute ``math_macros``, and if present it will
+    print the macro name in ``math_macros`` followed by a type suffix for the type
+    ``real``. e.g. printing ``sympy.pi`` would print ``M_PIl`` if real is mapped to float80.
+
+    """
+    @wraps(meth)
+    def _meth_wrapper(self, expr, **kwargs):
+        if expr in self.math_macros:
+            return '%s%s' % (self.math_macros[expr], self._get_math_macro_suffix(real))
+        else:
+            return meth(self, expr, **kwargs)
+
+    return _meth_wrapper
+
+
+class C89CodePrinter(CodePrinter):
+    """A printer to convert Python expressions to strings of C code"""
+    printmethod = "_ccode"
+    language = "C"
+    standard = "C89"
+    reserved_words = set(reserved_words)
+
+    _default_settings: dict[str, Any] = {
+        'order': None,
+        'full_prec': 'auto',
+        'precision': 17,
+        'user_functions': {},
+        'human': True,
+        'allow_unknown_functions': False,
+        'contract': True,
+        'dereference': set(),
+        'error_on_reserved': False,
+        'reserved_word_suffix': '_',
+    }
+
+    type_aliases = {
+        real: float64,
+        complex_: complex128,
+        integer: intc
+    }
+
+    type_mappings: dict[Type, Any] = {
+        real: 'double',
+        intc: 'int',
+        float32: 'float',
+        float64: 'double',
+        integer: 'int',
+        bool_: 'bool',
+        int8: 'int8_t',
+        int16: 'int16_t',
+        int32: 'int32_t',
+        int64: 'int64_t',
+        uint8: 'int8_t',
+        uint16: 'int16_t',
+        uint32: 'int32_t',
+        uint64: 'int64_t',
+    }
+
+    type_headers = {
+        bool_: {'stdbool.h'},
+        int8: {'stdint.h'},
+        int16: {'stdint.h'},
+        int32: {'stdint.h'},
+        int64: {'stdint.h'},
+        uint8: {'stdint.h'},
+        uint16: {'stdint.h'},
+        uint32: {'stdint.h'},
+        uint64: {'stdint.h'},
+    }
+
+    # Macros needed to be defined when using a Type
+    type_macros: dict[Type, tuple[str, ...]] = {}
+
+    type_func_suffixes = {
+        float32: 'f',
+        float64: '',
+        float80: 'l'
+    }
+
+    type_literal_suffixes = {
+        float32: 'F',
+        float64: '',
+        float80: 'L'
+    }
+
+    type_math_macro_suffixes = {
+        float80: 'l'
+    }
+
+    math_macros = None
+
+    _ns = ''  # namespace, C++ uses 'std::'
+    # known_functions-dict to copy
+    _kf: dict[str, Any] = known_functions_C89
+
+    def __init__(self, settings=None):
+        settings = settings or {}
+        if self.math_macros is None:
+            self.math_macros = settings.pop('math_macros', get_math_macros())
+        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()))
+        self.type_headers = dict(chain(self.type_headers.items(),
+                                       settings.pop('type_headers', {}).items()))
+        self.type_macros = dict(chain(self.type_macros.items(),
+                                       settings.pop('type_macros', {}).items()))
+        self.type_func_suffixes = dict(chain(self.type_func_suffixes.items(),
+                                        settings.pop('type_func_suffixes', {}).items()))
+        self.type_literal_suffixes = dict(chain(self.type_literal_suffixes.items(),
+                                        settings.pop('type_literal_suffixes', {}).items()))
+        self.type_math_macro_suffixes = dict(chain(self.type_math_macro_suffixes.items(),
+                                        settings.pop('type_math_macro_suffixes', {}).items()))
+        super().__init__(settings)
+        self.known_functions = dict(self._kf, **settings.get('user_functions', {}))
+        self._dereference = set(settings.get('dereference', []))
+        self.headers = set()
+        self.libraries = set()
+        self.macros = set()
+
+    def _rate_index_position(self, p):
+        return p*5
+
+    def _get_statement(self, codestring):
+        """ Get code string as a statement - i.e. ending with a semicolon. """
+        return codestring if codestring.endswith(';') else codestring + ';'
+
+    def _get_comment(self, text):
+        return "/* {} */".format(text)
+
+    def _declare_number_const(self, name, value):
+        type_ = self.type_aliases[real]
+        var = Variable(name, type=type_, value=value.evalf(type_.decimal_dig), attrs={value_const})
+        decl = Declaration(var)
+        return self._get_statement(self._print(decl))
+
+    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))
+
+    @_as_macro_if_defined
+    def _print_Mul(self, expr, **kwargs):
+        return super()._print_Mul(expr, **kwargs)
+
+    @_as_macro_if_defined
+    def _print_Pow(self, expr):
+        if "Pow" in self.known_functions:
+            return self._print_Function(expr)
+        PREC = precedence(expr)
+        suffix = self._get_func_suffix(real)
+        if equal_valued(expr.exp, -1):
+            literal_suffix = self._get_literal_suffix(real)
+            return '1.0%s/%s' % (literal_suffix, self.parenthesize(expr.base, PREC))
+        elif equal_valued(expr.exp, 0.5):
+            return '%ssqrt%s(%s)' % (self._ns, suffix, self._print(expr.base))
+        elif expr.exp == S.One/3 and self.standard != 'C89':
+            return '%scbrt%s(%s)' % (self._ns, suffix, self._print(expr.base))
+        else:
+            return '%spow%s(%s, %s)' % (self._ns, suffix, self._print(expr.base),
+                                   self._print(expr.exp))
+
+    def _print_Mod(self, expr):
+        num, den = expr.args
+        if num.is_integer and den.is_integer:
+            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 C. 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}"
+        # Not guaranteed integer
+        return self._print_math_func(expr, known='fmod')
+
+    def _print_Rational(self, expr):
+        p, q = int(expr.p), int(expr.q)
+        suffix = self._get_literal_suffix(real)
+        return '%d.0%s/%d.0%s' % (p, suffix, q, suffix)
+
+    def _print_Indexed(self, expr):
+        # calculate index for 1d array
+        offset = getattr(expr.base, 'offset', S.Zero)
+        strides = getattr(expr.base, 'strides', None)
+        indices = expr.indices
+
+        if strides is None or isinstance(strides, str):
+            dims = expr.shape
+            shift = S.One
+            temp = ()
+            if strides == 'C' or strides is None:
+                traversal = reversed(range(expr.rank))
+                indices = indices[::-1]
+            elif strides == 'F':
+                traversal = range(expr.rank)
+
+            for i in traversal:
+                temp += (shift,)
+                shift *= dims[i]
+            strides = temp
+        flat_index = sum([x[0]*x[1] for x in zip(indices, strides)]) + offset
+        return "%s[%s]" % (self._print(expr.base.label),
+                           self._print(flat_index))
+
+    def _print_Idx(self, expr):
+        return self._print(expr.label)
+
+    @_as_macro_if_defined
+    def _print_NumberSymbol(self, expr):
+        return super()._print_NumberSymbol(expr)
+
+    def _print_Infinity(self, expr):
+        return 'HUGE_VAL'
+
+    def _print_NegativeInfinity(self, expr):
+        return '-HUGE_VAL'
+
+    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) {" % 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_ITE(self, expr):
+        from sympy.functions import Piecewise
+        return self._print(expr.rewrite(Piecewise, deep=False))
+
+    def _print_MatrixElement(self, expr):
+        return "{}[{}]".format(self.parenthesize(expr.parent, PRECEDENCE["Atom"],
+            strict=True), expr.j + expr.i*expr.parent.shape[1])
+
+    def _print_Symbol(self, expr):
+        name = super()._print_Symbol(expr)
+        if expr in self._settings['dereference']:
+            return '(*{})'.format(name)
+        else:
+            return name
+
+    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_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 ('for ({target} = {start}; {target} < {stop}; {target} += '
+                '{step}) {{\n{body}\n}}').format(target=target, start=start,
+                stop=stop, step=step, body=body)
+
+    def _print_sign(self, func):
+        return '((({0}) > 0) - (({0}) < 0))'.format(self._print(func.args[0]))
+
+    def _print_Max(self, expr):
+        if "Max" in self.known_functions:
+            return self._print_Function(expr)
+        def inner_print_max(args): # The more natural abstraction of creating
+            if len(args) == 1:     # and printing smaller Max objects is slow
+                return self._print(args[0]) # when there are many arguments.
+            half = len(args) // 2
+            return "((%(a)s > %(b)s) ? %(a)s : %(b)s)" % {
+                'a': inner_print_max(args[:half]),
+                'b': inner_print_max(args[half:])
+            }
+        return inner_print_max(expr.args)
+
+    def _print_Min(self, expr):
+        if "Min" in self.known_functions:
+            return self._print_Function(expr)
+        def inner_print_min(args): # The more natural abstraction of creating
+            if len(args) == 1:     # and printing smaller Min objects is slow
+                return self._print(args[0]) # when there are many arguments.
+            half = len(args) // 2
+            return "((%(a)s < %(b)s) ? %(a)s : %(b)s)" % {
+                'a': inner_print_min(args[:half]),
+                'b': inner_print_min(args[half:])
+            }
+        return inner_print_min(expr.args)
+
+    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 _get_func_suffix(self, type_):
+        return self.type_func_suffixes[self.type_aliases.get(type_, type_)]
+
+    def _get_literal_suffix(self, type_):
+        return self.type_literal_suffixes[self.type_aliases.get(type_, type_)]
+
+    def _get_math_macro_suffix(self, type_):
+        alias = self.type_aliases.get(type_, type_)
+        dflt = self.type_math_macro_suffixes.get(alias, '')
+        return self.type_math_macro_suffixes.get(type_, dflt)
+
+    def _print_Tuple(self, expr):
+        return '{'+', '.join(self._print(e) for e in expr)+'}'
+
+    _print_List = _print_Tuple
+
+    def _print_Type(self, type_):
+        self.headers.update(self.type_headers.get(type_, set()))
+        self.macros.update(self.type_macros.get(type_, set()))
+        return self._print(self.type_mappings.get(type_, type_.name))
+
+    def _print_Declaration(self, decl):
+        from sympy.codegen.cnodes import restrict
+        var = decl.variable
+        val = var.value
+        if var.type == untyped:
+            raise ValueError("C does not support untyped variables")
+
+        if isinstance(var, Pointer):
+            result = '{vc}{t} *{pc} {r}{s}'.format(
+                vc='const ' if value_const in var.attrs else '',
+                t=self._print(var.type),
+                pc=' const' if pointer_const in var.attrs else '',
+                r='restrict ' if restrict in var.attrs else '',
+                s=self._print(var.symbol)
+            )
+        elif isinstance(var, Variable):
+            result = '{vc}{t} {s}'.format(
+                vc='const ' if value_const in var.attrs else '',
+                t=self._print(var.type),
+                s=self._print(var.symbol)
+            )
+        else:
+            raise NotImplementedError("Unknown type of var: %s" % type(var))
+        if val != None: # Must be "!= None", cannot be "is not None"
+            result += ' = %s' % self._print(val)
+        return result
+
+    def _print_Float(self, flt):
+        type_ = self.type_aliases.get(real, real)
+        self.macros.update(self.type_macros.get(type_, set()))
+        suffix = self._get_literal_suffix(type_)
+        num = str(flt.evalf(type_.decimal_dig))
+        if 'e' not in num and '.' not in num:
+            num += '.0'
+        num_parts = num.split('e')
+        num_parts[0] = num_parts[0].rstrip('0')
+        if num_parts[0].endswith('.'):
+            num_parts[0] += '0'
+        return 'e'.join(num_parts) + suffix
+
+    @requires(headers={'stdbool.h'})
+    def _print_BooleanTrue(self, expr):
+        return 'true'
+
+    @requires(headers={'stdbool.h'})
+    def _print_BooleanFalse(self, expr):
+        return 'false'
+
+    def _print_Element(self, elem):
+        if elem.strides == None: # Must be "== None", cannot be "is None"
+            if elem.offset != None: # Must be "!= None", cannot be "is not None"
+                raise ValueError("Expected strides when offset is given")
+            idxs = ']['.join((self._print(arg) for arg in elem.indices))
+        else:
+            global_idx = sum([i*s for i, s in zip(elem.indices, elem.strides)])
+            if elem.offset != None: # Must be "!= None", cannot be "is not None"
+                global_idx += elem.offset
+            idxs = self._print(global_idx)
+
+        return "{symb}[{idxs}]".format(
+            symb=self._print(elem.symbol),
+            idxs=idxs
+        )
+
+    def _print_CodeBlock(self, expr):
+        """ Elements of code blocks printed as statements. """
+        return '\n'.join([self._get_statement(self._print(i)) for i in expr.args])
+
+    def _print_While(self, expr):
+        return 'while ({condition}) {{\n{body}\n}}'.format(**expr.kwargs(
+            apply=lambda arg: self._print(arg)))
+
+    def _print_Scope(self, expr):
+        return '{\n%s\n}' % self._print_CodeBlock(expr.body)
+
+    @requires(headers={'stdio.h'})
+    def _print_Print(self, expr):
+        return 'printf({fmt}, {pargs})'.format(
+            fmt=self._print(expr.format_string),
+            pargs=', '.join((self._print(arg) for arg in expr.print_args))
+        )
+
+    def _print_FunctionPrototype(self, expr):
+        pars = ', '.join((self._print(Declaration(arg)) for arg in expr.parameters))
+        return "%s %s(%s)" % (
+            tuple((self._print(arg) for arg in (expr.return_type, expr.name))) + (pars,)
+        )
+
+    def _print_FunctionDefinition(self, expr):
+        return "%s%s" % (self._print_FunctionPrototype(expr),
+                         self._print_Scope(expr))
+
+    def _print_Return(self, expr):
+        arg, = expr.args
+        return 'return %s' % self._print(arg)
+
+    def _print_CommaOperator(self, expr):
+        return '(%s)' % ', '.join((self._print(arg) for arg in expr.args))
+
+    def _print_Label(self, expr):
+        if expr.body == none:
+            return '%s:' % str(expr.name)
+        if len(expr.body.args) == 1:
+            return '%s:\n%s' % (str(expr.name), self._print_CodeBlock(expr.body))
+        return '%s:\n{\n%s\n}' % (str(expr.name), self._print_CodeBlock(expr.body))
+
+    def _print_goto(self, expr):
+        return 'goto %s' % expr.label.name
+
+    def _print_PreIncrement(self, expr):
+        arg, = expr.args
+        return '++(%s)' % self._print(arg)
+
+    def _print_PostIncrement(self, expr):
+        arg, = expr.args
+        return '(%s)++' % self._print(arg)
+
+    def _print_PreDecrement(self, expr):
+        arg, = expr.args
+        return '--(%s)' % self._print(arg)
+
+    def _print_PostDecrement(self, expr):
+        arg, = expr.args
+        return '(%s)--' % self._print(arg)
+
+    def _print_struct(self, expr):
+        return "%(keyword)s %(name)s {\n%(lines)s}" % {
+            "keyword": expr.__class__.__name__, "name": expr.name, "lines": ';\n'.join(
+                [self._print(decl) for decl in expr.declarations] + [''])
+        }
+
+    def _print_BreakToken(self, _):
+        return 'break'
+
+    def _print_ContinueToken(self, _):
+        return 'continue'
+
+    _print_union = _print_struct
+
+class C99CodePrinter(C89CodePrinter):
+    standard = 'C99'
+    reserved_words = set(reserved_words + reserved_words_c99)
+    type_mappings=dict(chain(C89CodePrinter.type_mappings.items(), {
+        complex64: 'float complex',
+        complex128: 'double complex',
+    }.items()))
+    type_headers = dict(chain(C89CodePrinter.type_headers.items(), {
+        complex64: {'complex.h'},
+        complex128: {'complex.h'}
+    }.items()))
+
+    # known_functions-dict to copy
+    _kf: dict[str, Any] = known_functions_C99
+
+    # functions with versions with 'f' and 'l' suffixes:
+    _prec_funcs = ('fabs fmod remainder remquo fma fmax fmin fdim nan exp exp2'
+                   ' expm1 log log10 log2 log1p pow sqrt cbrt hypot sin cos tan'
+                   ' asin acos atan atan2 sinh cosh tanh asinh acosh atanh erf'
+                   ' erfc tgamma lgamma ceil floor trunc round nearbyint rint'
+                   ' frexp ldexp modf scalbn ilogb logb nextafter copysign').split()
+
+    def _print_Infinity(self, expr):
+        return 'INFINITY'
+
+    def _print_NegativeInfinity(self, expr):
+        return '-INFINITY'
+
+    def _print_NaN(self, expr):
+        return 'NAN'
+
+    # tgamma was already covered by 'known_functions' dict
+
+    @requires(headers={'math.h'}, libraries={'m'})
+    @_as_macro_if_defined
+    def _print_math_func(self, expr, nest=False, known=None):
+        if known is None:
+            known = self.known_functions[expr.__class__.__name__]
+        if not isinstance(known, str):
+            for cb, name in known:
+                if cb(*expr.args):
+                    known = name
+                    break
+            else:
+                raise ValueError("No matching printer")
+        try:
+            return known(self, *expr.args)
+        except TypeError:
+            suffix = self._get_func_suffix(real) if self._ns + known in self._prec_funcs else ''
+
+        if nest:
+            args = self._print(expr.args[0])
+            if len(expr.args) > 1:
+                paren_pile = ''
+                for curr_arg in expr.args[1:-1]:
+                    paren_pile += ')'
+                    args += ', {ns}{name}{suffix}({next}'.format(
+                        ns=self._ns,
+                        name=known,
+                        suffix=suffix,
+                        next = self._print(curr_arg)
+                    )
+                args += ', %s%s' % (
+                    self._print(expr.func(expr.args[-1])),
+                    paren_pile
+                )
+        else:
+            args = ', '.join((self._print(arg) for arg in expr.args))
+        return '{ns}{name}{suffix}({args})'.format(
+            ns=self._ns,
+            name=known,
+            suffix=suffix,
+            args=args
+        )
+
+    def _print_Max(self, expr):
+        return self._print_math_func(expr, nest=True)
+
+    def _print_Min(self, expr):
+        return self._print_math_func(expr, nest=True)
+
+    def _get_loop_opening_ending(self, indices):
+        open_lines = []
+        close_lines = []
+        loopstart = "for (int %(var)s=%(start)s; %(var)s<%(end)s; %(var)s++){"  # C99
+        for i in indices:
+            # C arrays start at 0 and end at dimension-1
+            open_lines.append(loopstart % {
+                'var': self._print(i.label),
+                'start': self._print(i.lower),
+                'end': self._print(i.upper + 1)})
+            close_lines.append("}")
+        return open_lines, close_lines
+
+
+for k in ('Abs Sqrt exp exp2 expm1 log log10 log2 log1p Cbrt hypot fma'
+          ' loggamma sin cos tan asin acos atan atan2 sinh cosh tanh asinh acosh '
+          'atanh erf erfc loggamma gamma ceiling floor').split():
+    setattr(C99CodePrinter, '_print_%s' % k, C99CodePrinter._print_math_func)
+
+
+class C11CodePrinter(C99CodePrinter):
+
+    @requires(headers={'stdalign.h'})
+    def _print_alignof(self, expr):
+        arg, = expr.args
+        return 'alignof(%s)' % self._print(arg)
+
+
+c_code_printers = {
+    'c89': C89CodePrinter,
+    'c99': C99CodePrinter,
+    'c11': C11CodePrinter
+}

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

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

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

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

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

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

@@ -0,0 +1,294 @@
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr
+from sympy.core.symbol import Symbol
+from sympy.core.numbers import Integer, Rational, Float
+from sympy.printing.repr import srepr
+
+__all__ = ['dotprint']
+
+default_styles = (
+    (Basic, {'color': 'blue', 'shape': 'ellipse'}),
+    (Expr,  {'color': 'black'})
+)
+
+slotClasses = (Symbol, Integer, Rational, Float)
+def purestr(x, with_args=False):
+    """A string that follows ```obj = type(obj)(*obj.args)``` exactly.
+
+    Parameters
+    ==========
+
+    with_args : boolean, optional
+        If ``True``, there will be a second argument for the return
+        value, which is a tuple containing ``purestr`` applied to each
+        of the subnodes.
+
+        If ``False``, there will not be a second argument for the
+        return.
+
+        Default is ``False``
+
+    Examples
+    ========
+
+    >>> from sympy import Float, Symbol, MatrixSymbol
+    >>> from sympy import Integer # noqa: F401
+    >>> from sympy.core.symbol import Str # noqa: F401
+    >>> from sympy.printing.dot import purestr
+
+    Applying ``purestr`` for basic symbolic object:
+    >>> code = purestr(Symbol('x'))
+    >>> code
+    "Symbol('x')"
+    >>> eval(code) == Symbol('x')
+    True
+
+    For basic numeric object:
+    >>> purestr(Float(2))
+    "Float('2.0', precision=53)"
+
+    For matrix symbol:
+    >>> code = purestr(MatrixSymbol('x', 2, 2))
+    >>> code
+    "MatrixSymbol(Str('x'), Integer(2), Integer(2))"
+    >>> eval(code) == MatrixSymbol('x', 2, 2)
+    True
+
+    With ``with_args=True``:
+    >>> purestr(Float(2), with_args=True)
+    ("Float('2.0', precision=53)", ())
+    >>> purestr(MatrixSymbol('x', 2, 2), with_args=True)
+    ("MatrixSymbol(Str('x'), Integer(2), Integer(2))",
+     ("Str('x')", 'Integer(2)', 'Integer(2)'))
+    """
+    sargs = ()
+    if not isinstance(x, Basic):
+        rv = str(x)
+    elif not x.args:
+        rv = srepr(x)
+    else:
+        args = x.args
+        sargs = tuple(map(purestr, args))
+        rv = "%s(%s)"%(type(x).__name__, ', '.join(sargs))
+    if with_args:
+        rv = rv, sargs
+    return rv
+
+
+def styleof(expr, styles=default_styles):
+    """ Merge style dictionaries in order
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, Basic, Expr, S
+    >>> from sympy.printing.dot import styleof
+    >>> styles = [(Basic, {'color': 'blue', 'shape': 'ellipse'}),
+    ...           (Expr,  {'color': 'black'})]
+
+    >>> styleof(Basic(S(1)), styles)
+    {'color': 'blue', 'shape': 'ellipse'}
+
+    >>> x = Symbol('x')
+    >>> styleof(x + 1, styles)  # this is an Expr
+    {'color': 'black', 'shape': 'ellipse'}
+    """
+    style = {}
+    for typ, sty in styles:
+        if isinstance(expr, typ):
+            style.update(sty)
+    return style
+
+
+def attrprint(d, delimiter=', '):
+    """ Print a dictionary of attributes
+
+    Examples
+    ========
+
+    >>> from sympy.printing.dot import attrprint
+    >>> print(attrprint({'color': 'blue', 'shape': 'ellipse'}))
+    "color"="blue", "shape"="ellipse"
+    """
+    return delimiter.join('"%s"="%s"'%item for item in sorted(d.items()))
+
+
+def dotnode(expr, styles=default_styles, labelfunc=str, pos=(), repeat=True):
+    """ String defining a node
+
+    Examples
+    ========
+
+    >>> from sympy.printing.dot import dotnode
+    >>> from sympy.abc import x
+    >>> print(dotnode(x))
+    "Symbol('x')_()" ["color"="black", "label"="x", "shape"="ellipse"];
+    """
+    style = styleof(expr, styles)
+
+    if isinstance(expr, Basic) and not expr.is_Atom:
+        label = str(expr.__class__.__name__)
+    else:
+        label = labelfunc(expr)
+    style['label'] = label
+    expr_str = purestr(expr)
+    if repeat:
+        expr_str += '_%s' % str(pos)
+    return '"%s" [%s];' % (expr_str, attrprint(style))
+
+
+def dotedges(expr, atom=lambda x: not isinstance(x, Basic), pos=(), repeat=True):
+    """ List of strings for all expr->expr.arg pairs
+
+    See the docstring of dotprint for explanations of the options.
+
+    Examples
+    ========
+
+    >>> from sympy.printing.dot import dotedges
+    >>> from sympy.abc import x
+    >>> for e in dotedges(x+2):
+    ...     print(e)
+    "Add(Integer(2), Symbol('x'))_()" -> "Integer(2)_(0,)";
+    "Add(Integer(2), Symbol('x'))_()" -> "Symbol('x')_(1,)";
+    """
+    if atom(expr):
+        return []
+    else:
+        expr_str, arg_strs = purestr(expr, with_args=True)
+        if repeat:
+            expr_str += '_%s' % str(pos)
+            arg_strs = ['%s_%s' % (a, str(pos + (i,)))
+                for i, a in enumerate(arg_strs)]
+        return ['"%s" -> "%s";' % (expr_str, a) for a in arg_strs]
+
+template = \
+"""digraph{
+
+# Graph style
+%(graphstyle)s
+
+#########
+# Nodes #
+#########
+
+%(nodes)s
+
+#########
+# Edges #
+#########
+
+%(edges)s
+}"""
+
+_graphstyle = {'rankdir': 'TD', 'ordering': 'out'}
+
+def dotprint(expr,
+    styles=default_styles, atom=lambda x: not isinstance(x, Basic),
+    maxdepth=None, repeat=True, labelfunc=str, **kwargs):
+    """DOT description of a SymPy expression tree
+
+    Parameters
+    ==========
+
+    styles : list of lists composed of (Class, mapping), optional
+        Styles for different classes.
+
+        The default is
+
+        .. code-block:: python
+
+            (
+                (Basic, {'color': 'blue', 'shape': 'ellipse'}),
+                (Expr,  {'color': 'black'})
+            )
+
+    atom : function, optional
+        Function used to determine if an arg is an atom.
+
+        A good choice is ``lambda x: not x.args``.
+
+        The default is ``lambda x: not isinstance(x, Basic)``.
+
+    maxdepth : integer, optional
+        The maximum depth.
+
+        The default is ``None``, meaning no limit.
+
+    repeat : boolean, optional
+        Whether to use different nodes for common subexpressions.
+
+        The default is ``True``.
+
+        For example, for ``x + x*y`` with ``repeat=True``, it will have
+        two nodes for ``x``; with ``repeat=False``, it will have one
+        node.
+
+        .. warning::
+            Even if a node appears twice in the same object like ``x`` in
+            ``Pow(x, x)``, it will still only appear once.
+            Hence, with ``repeat=False``, the number of arrows out of an
+            object might not equal the number of args it has.
+
+    labelfunc : function, optional
+        A function to create a label for a given leaf node.
+
+        The default is ``str``.
+
+        Another good option is ``srepr``.
+
+        For example with ``str``, the leaf nodes of ``x + 1`` are labeled,
+        ``x`` and ``1``.  With ``srepr``, they are labeled ``Symbol('x')``
+        and ``Integer(1)``.
+
+    **kwargs : optional
+        Additional keyword arguments are included as styles for the graph.
+
+    Examples
+    ========
+
+    >>> from sympy import dotprint
+    >>> from sympy.abc import x
+    >>> print(dotprint(x+2)) # doctest: +NORMALIZE_WHITESPACE
+    digraph{
+    <BLANKLINE>
+    # Graph style
+    "ordering"="out"
+    "rankdir"="TD"
+    <BLANKLINE>
+    #########
+    # Nodes #
+    #########
+    <BLANKLINE>
+    "Add(Integer(2), Symbol('x'))_()" ["color"="black", "label"="Add", "shape"="ellipse"];
+    "Integer(2)_(0,)" ["color"="black", "label"="2", "shape"="ellipse"];
+    "Symbol('x')_(1,)" ["color"="black", "label"="x", "shape"="ellipse"];
+    <BLANKLINE>
+    #########
+    # Edges #
+    #########
+    <BLANKLINE>
+    "Add(Integer(2), Symbol('x'))_()" -> "Integer(2)_(0,)";
+    "Add(Integer(2), Symbol('x'))_()" -> "Symbol('x')_(1,)";
+    }
+
+    """
+    # repeat works by adding a signature tuple to the end of each node for its
+    # position in the graph. For example, for expr = Add(x, Pow(x, 2)), the x in the
+    # Pow will have the tuple (1, 0), meaning it is expr.args[1].args[0].
+    graphstyle = _graphstyle.copy()
+    graphstyle.update(kwargs)
+
+    nodes = []
+    edges = []
+    def traverse(e, depth, pos=()):
+        nodes.append(dotnode(e, styles, labelfunc=labelfunc, pos=pos, repeat=repeat))
+        if maxdepth and depth >= maxdepth:
+            return
+        edges.extend(dotedges(e, atom=atom, pos=pos, repeat=repeat))
+        [traverse(arg, depth+1, pos + (i,)) for i, arg in enumerate(e.args) if not atom(arg)]
+    traverse(expr, 0)
+
+    return template%{'graphstyle': attrprint(graphstyle, delimiter='\n'),
+                     'nodes': '\n'.join(nodes),
+                     'edges': '\n'.join(edges)}

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

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

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

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

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

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

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

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

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