Add files using upload-large-folder tool

lib/python3.12/site-packages/sympy/printing/pretty/stringpict.py

@@ -0,0 +1,537 @@
+"""Prettyprinter by Jurjen Bos.
+(I hate spammers: mail me at pietjepuk314 at the reverse of ku.oc.oohay).
+All objects have a method that create a "stringPict",
+that can be used in the str method for pretty printing.
+
+Updates by Jason Gedge (email <my last name> at cs mun ca)
+    - terminal_string() method
+    - minor fixes and changes (mostly to prettyForm)
+
+TODO:
+    - Allow left/center/right alignment options for above/below and
+      top/center/bottom alignment options for left/right
+"""
+
+import shutil
+
+from .pretty_symbology import hobj, vobj, xsym, xobj, pretty_use_unicode, line_width, center
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+_GLOBAL_WRAP_LINE = None
+
+class stringPict:
+    """An ASCII picture.
+    The pictures are represented as a list of equal length strings.
+    """
+    #special value for stringPict.below
+    LINE = 'line'
+
+    def __init__(self, s, baseline=0):
+        """Initialize from string.
+        Multiline strings are centered.
+        """
+        self.s = s
+        #picture is a string that just can be printed
+        self.picture = stringPict.equalLengths(s.splitlines())
+        #baseline is the line number of the "base line"
+        self.baseline = baseline
+        self.binding = None
+
+    @staticmethod
+    def equalLengths(lines):
+        # empty lines
+        if not lines:
+            return ['']
+
+        width = max(line_width(line) for line in lines)
+        return [center(line, width) for line in lines]
+
+    def height(self):
+        """The height of the picture in characters."""
+        return len(self.picture)
+
+    def width(self):
+        """The width of the picture in characters."""
+        return line_width(self.picture[0])
+
+    @staticmethod
+    def next(*args):
+        """Put a string of stringPicts next to each other.
+        Returns string, baseline arguments for stringPict.
+        """
+        #convert everything to stringPicts
+        objects = []
+        for arg in args:
+            if isinstance(arg, str):
+                arg = stringPict(arg)
+            objects.append(arg)
+
+        #make a list of pictures, with equal height and baseline
+        newBaseline = max(obj.baseline for obj in objects)
+        newHeightBelowBaseline = max(
+            obj.height() - obj.baseline
+            for obj in objects)
+        newHeight = newBaseline + newHeightBelowBaseline
+
+        pictures = []
+        for obj in objects:
+            oneEmptyLine = [' '*obj.width()]
+            basePadding = newBaseline - obj.baseline
+            totalPadding = newHeight - obj.height()
+            pictures.append(
+                oneEmptyLine * basePadding +
+                obj.picture +
+                oneEmptyLine * (totalPadding - basePadding))
+
+        result = [''.join(lines) for lines in zip(*pictures)]
+        return '\n'.join(result), newBaseline
+
+    def right(self, *args):
+        r"""Put pictures next to this one.
+        Returns string, baseline arguments for stringPict.
+        (Multiline) strings are allowed, and are given a baseline of 0.
+
+        Examples
+        ========
+
+        >>> from sympy.printing.pretty.stringpict import stringPict
+        >>> print(stringPict("10").right(" + ",stringPict("1\r-\r2",1))[0])
+             1
+        10 + -
+             2
+
+        """
+        return stringPict.next(self, *args)
+
+    def left(self, *args):
+        """Put pictures (left to right) at left.
+        Returns string, baseline arguments for stringPict.
+        """
+        return stringPict.next(*(args + (self,)))
+
+    @staticmethod
+    def stack(*args):
+        """Put pictures on top of each other,
+        from top to bottom.
+        Returns string, baseline arguments for stringPict.
+        The baseline is the baseline of the second picture.
+        Everything is centered.
+        Baseline is the baseline of the second picture.
+        Strings are allowed.
+        The special value stringPict.LINE is a row of '-' extended to the width.
+        """
+        #convert everything to stringPicts; keep LINE
+        objects = []
+        for arg in args:
+            if arg is not stringPict.LINE and isinstance(arg, str):
+                arg = stringPict(arg)
+            objects.append(arg)
+
+        #compute new width
+        newWidth = max(
+            obj.width()
+            for obj in objects
+            if obj is not stringPict.LINE)
+
+        lineObj = stringPict(hobj('-', newWidth))
+
+        #replace LINE with proper lines
+        for i, obj in enumerate(objects):
+            if obj is stringPict.LINE:
+                objects[i] = lineObj
+
+        #stack the pictures, and center the result
+        newPicture = [center(line, newWidth) for obj in objects for line in obj.picture]
+        newBaseline = objects[0].height() + objects[1].baseline
+        return '\n'.join(newPicture), newBaseline
+
+    def below(self, *args):
+        """Put pictures under this picture.
+        Returns string, baseline arguments for stringPict.
+        Baseline is baseline of top picture
+
+        Examples
+        ========
+
+        >>> from sympy.printing.pretty.stringpict import stringPict
+        >>> print(stringPict("x+3").below(
+        ...       stringPict.LINE, '3')[0]) #doctest: +NORMALIZE_WHITESPACE
+        x+3
+        ---
+         3
+
+        """
+        s, baseline = stringPict.stack(self, *args)
+        return s, self.baseline
+
+    def above(self, *args):
+        """Put pictures above this picture.
+        Returns string, baseline arguments for stringPict.
+        Baseline is baseline of bottom picture.
+        """
+        string, baseline = stringPict.stack(*(args + (self,)))
+        baseline = len(string.splitlines()) - self.height() + self.baseline
+        return string, baseline
+
+    def parens(self, left='(', right=')', ifascii_nougly=False):
+        """Put parentheses around self.
+        Returns string, baseline arguments for stringPict.
+
+        left or right can be None or empty string which means 'no paren from
+        that side'
+        """
+        h = self.height()
+        b = self.baseline
+
+        # XXX this is a hack -- ascii parens are ugly!
+        if ifascii_nougly and not pretty_use_unicode():
+            h = 1
+            b = 0
+
+        res = self
+
+        if left:
+            lparen = stringPict(vobj(left, h), baseline=b)
+            res = stringPict(*lparen.right(self))
+        if right:
+            rparen = stringPict(vobj(right, h), baseline=b)
+            res = stringPict(*res.right(rparen))
+
+        return ('\n'.join(res.picture), res.baseline)
+
+    def leftslash(self):
+        """Precede object by a slash of the proper size.
+        """
+        # XXX not used anywhere ?
+        height = max(
+            self.baseline,
+            self.height() - 1 - self.baseline)*2 + 1
+        slash = '\n'.join(
+            ' '*(height - i - 1) + xobj('/', 1) + ' '*i
+            for i in range(height)
+        )
+        return self.left(stringPict(slash, height//2))
+
+    def root(self, n=None):
+        """Produce a nice root symbol.
+        Produces ugly results for big n inserts.
+        """
+        # XXX not used anywhere
+        # XXX duplicate of root drawing in pretty.py
+        #put line over expression
+        result = self.above('_'*self.width())
+        #construct right half of root symbol
+        height = self.height()
+        slash = '\n'.join(
+            ' ' * (height - i - 1) + '/' + ' ' * i
+            for i in range(height)
+        )
+        slash = stringPict(slash, height - 1)
+        #left half of root symbol
+        if height > 2:
+            downline = stringPict('\\ \n \\', 1)
+        else:
+            downline = stringPict('\\')
+        #put n on top, as low as possible
+        if n is not None and n.width() > downline.width():
+            downline = downline.left(' '*(n.width() - downline.width()))
+            downline = downline.above(n)
+        #build root symbol
+        root = downline.right(slash)
+        #glue it on at the proper height
+        #normally, the root symbel is as high as self
+        #which is one less than result
+        #this moves the root symbol one down
+        #if the root became higher, the baseline has to grow too
+        root.baseline = result.baseline - result.height() + root.height()
+        return result.left(root)
+
+    def render(self, * args, **kwargs):
+        """Return the string form of self.
+
+           Unless the argument line_break is set to False, it will
+           break the expression in a form that can be printed
+           on the terminal without being broken up.
+         """
+        if _GLOBAL_WRAP_LINE is not None:
+            kwargs["wrap_line"] = _GLOBAL_WRAP_LINE
+
+        if kwargs["wrap_line"] is False:
+            return "\n".join(self.picture)
+
+        if kwargs["num_columns"] is not None:
+            # Read the argument num_columns if it is not None
+            ncols = kwargs["num_columns"]
+        else:
+            # Attempt to get a terminal width
+            ncols = self.terminal_width()
+
+        if ncols <= 0:
+            ncols = 80
+
+        # If smaller than the terminal width, no need to correct
+        if self.width() <= ncols:
+            return type(self.picture[0])(self)
+
+        """
+        Break long-lines in a visually pleasing format.
+        without overflow indicators | with overflow indicators
+        |   2  2        3     |     |   2  2        3    ↪|
+        |6*x *y  + 4*x*y  +   |     |6*x *y  + 4*x*y  +  ↪|
+        |                     |     |                     |
+        |     3    4    4     |     |↪      3    4    4   |
+        |4*y*x  + x  + y      |     |↪ 4*y*x  + x  + y    |
+        |a*c*e + a*c*f + a*d  |     |a*c*e + a*c*f + a*d ↪|
+        |*e + a*d*f + b*c*e   |     |                     |
+        |+ b*c*f + b*d*e + b  |     |↪ *e + a*d*f + b*c* ↪|
+        |*d*f                 |     |                     |
+        |                     |     |↪ e + b*c*f + b*d*e ↪|
+        |                     |     |                     |
+        |                     |     |↪ + b*d*f            |
+        """
+
+        overflow_first = ""
+        if kwargs["use_unicode"] or pretty_use_unicode():
+            overflow_start = "\N{RIGHTWARDS ARROW WITH HOOK} "
+            overflow_end   = " \N{RIGHTWARDS ARROW WITH HOOK}"
+        else:
+            overflow_start = "> "
+            overflow_end   = " >"
+
+        def chunks(line):
+            """Yields consecutive chunks of line_width ncols"""
+            prefix = overflow_first
+            width, start = line_width(prefix + overflow_end), 0
+            for i, x in enumerate(line):
+                wx = line_width(x)
+                # Only flush the screen when the current character overflows.
+                # This way, combining marks can be appended even when width == ncols.
+                if width + wx > ncols:
+                    yield prefix + line[start:i] + overflow_end
+                    prefix = overflow_start
+                    width, start = line_width(prefix + overflow_end), i
+                width += wx
+            yield prefix + line[start:]
+
+        # Concurrently assemble chunks of all lines into individual screens
+        pictures = zip(*map(chunks, self.picture))
+
+        # Join lines of each screen into sub-pictures
+        pictures = ["\n".join(picture) for picture in pictures]
+
+        # Add spacers between sub-pictures
+        return "\n\n".join(pictures)
+
+    def terminal_width(self):
+        """Return the terminal width if possible, otherwise return 0.
+        """
+        size = shutil.get_terminal_size(fallback=(0, 0))
+        return size.columns
+
+    def __eq__(self, o):
+        if isinstance(o, str):
+            return '\n'.join(self.picture) == o
+        elif isinstance(o, stringPict):
+            return o.picture == self.picture
+        return False
+
+    def __hash__(self):
+        return super().__hash__()
+
+    def __str__(self):
+        return '\n'.join(self.picture)
+
+    def __repr__(self):
+        return "stringPict(%r,%d)" % ('\n'.join(self.picture), self.baseline)
+
+    def __getitem__(self, index):
+        return self.picture[index]
+
+    def __len__(self):
+        return len(self.s)
+
+
+class prettyForm(stringPict):
+    """
+    Extension of the stringPict class that knows about basic math applications,
+    optimizing double minus signs.
+
+    "Binding" is interpreted as follows::
+
+        ATOM this is an atom: never needs to be parenthesized
+        FUNC this is a function application: parenthesize if added (?)
+        DIV  this is a division: make wider division if divided
+        POW  this is a power: only parenthesize if exponent
+        MUL  this is a multiplication: parenthesize if powered
+        ADD  this is an addition: parenthesize if multiplied or powered
+        NEG  this is a negative number: optimize if added, parenthesize if
+             multiplied or powered
+        OPEN this is an open object: parenthesize if added, multiplied, or
+             powered (example: Piecewise)
+    """
+    ATOM, FUNC, DIV, POW, MUL, ADD, NEG, OPEN = range(8)
+
+    def __init__(self, s, baseline=0, binding=0, unicode=None):
+        """Initialize from stringPict and binding power."""
+        stringPict.__init__(self, s, baseline)
+        self.binding = binding
+        if unicode is not None:
+            sympy_deprecation_warning(
+                """
+                The unicode argument to prettyForm is deprecated. Only the s
+                argument (the first positional argument) should be passed.
+                """,
+                deprecated_since_version="1.7",
+                active_deprecations_target="deprecated-pretty-printing-functions")
+        self._unicode = unicode or s
+
+    @property
+    def unicode(self):
+        sympy_deprecation_warning(
+            """
+            The prettyForm.unicode attribute is deprecated. Use the
+            prettyForm.s attribute instead.
+            """,
+            deprecated_since_version="1.7",
+            active_deprecations_target="deprecated-pretty-printing-functions")
+        return self._unicode
+
+    # Note: code to handle subtraction is in _print_Add
+
+    def __add__(self, *others):
+        """Make a pretty addition.
+        Addition of negative numbers is simplified.
+        """
+        arg = self
+        if arg.binding > prettyForm.NEG:
+            arg = stringPict(*arg.parens())
+        result = [arg]
+        for arg in others:
+            #add parentheses for weak binders
+            if arg.binding > prettyForm.NEG:
+                arg = stringPict(*arg.parens())
+            #use existing minus sign if available
+            if arg.binding != prettyForm.NEG:
+                result.append(' + ')
+            result.append(arg)
+        return prettyForm(binding=prettyForm.ADD, *stringPict.next(*result))
+
+    def __truediv__(self, den, slashed=False):
+        """Make a pretty division; stacked or slashed.
+        """
+        if slashed:
+            raise NotImplementedError("Can't do slashed fraction yet")
+        num = self
+        if num.binding == prettyForm.DIV:
+            num = stringPict(*num.parens())
+        if den.binding == prettyForm.DIV:
+            den = stringPict(*den.parens())
+
+        if num.binding==prettyForm.NEG:
+            num = num.right(" ")[0]
+
+        return prettyForm(binding=prettyForm.DIV, *stringPict.stack(
+            num,
+            stringPict.LINE,
+            den))
+
+    def __mul__(self, *others):
+        """Make a pretty multiplication.
+        Parentheses are needed around +, - and neg.
+        """
+        quantity = {
+            'degree': "\N{DEGREE SIGN}"
+        }
+
+        if len(others) == 0:
+            return self  # We aren't actually multiplying... So nothing to do here.
+
+        # add parens on args that need them
+        arg = self
+        if arg.binding > prettyForm.MUL and arg.binding != prettyForm.NEG:
+            arg = stringPict(*arg.parens())
+        result = [arg]
+        for arg in others:
+            if arg.picture[0] not in quantity.values():
+                result.append(xsym('*'))
+            #add parentheses for weak binders
+            if arg.binding > prettyForm.MUL and arg.binding != prettyForm.NEG:
+                arg = stringPict(*arg.parens())
+            result.append(arg)
+
+        len_res = len(result)
+        for i in range(len_res):
+            if i < len_res - 1 and result[i] == '-1' and result[i + 1] == xsym('*'):
+                # substitute -1 by -, like in -1*x -> -x
+                result.pop(i)
+                result.pop(i)
+                result.insert(i, '-')
+        if result[0][0] == '-':
+            # if there is a - sign in front of all
+            # This test was failing to catch a prettyForm.__mul__(prettyForm("-1", 0, 6)) being negative
+            bin = prettyForm.NEG
+            if result[0] == '-':
+                right = result[1]
+                if right.picture[right.baseline][0] == '-':
+                    result[0] = '- '
+        else:
+            bin = prettyForm.MUL
+        return prettyForm(binding=bin, *stringPict.next(*result))
+
+    def __repr__(self):
+        return "prettyForm(%r,%d,%d)" % (
+            '\n'.join(self.picture),
+            self.baseline,
+            self.binding)
+
+    def __pow__(self, b):
+        """Make a pretty power.
+        """
+        a = self
+        use_inline_func_form = False
+        if b.binding == prettyForm.POW:
+            b = stringPict(*b.parens())
+        if a.binding > prettyForm.FUNC:
+            a = stringPict(*a.parens())
+        elif a.binding == prettyForm.FUNC:
+            # heuristic for when to use inline power
+            if b.height() > 1:
+                a = stringPict(*a.parens())
+            else:
+                use_inline_func_form = True
+
+        if use_inline_func_form:
+            #         2
+            #  sin  +   + (x)
+            b.baseline = a.prettyFunc.baseline + b.height()
+            func = stringPict(*a.prettyFunc.right(b))
+            return prettyForm(*func.right(a.prettyArgs))
+        else:
+            #      2    <-- top
+            # (x+y)     <-- bot
+            top = stringPict(*b.left(' '*a.width()))
+            bot = stringPict(*a.right(' '*b.width()))
+
+        return prettyForm(binding=prettyForm.POW, *bot.above(top))
+
+    simpleFunctions = ["sin", "cos", "tan"]
+
+    @staticmethod
+    def apply(function, *args):
+        """Functions of one or more variables.
+        """
+        if function in prettyForm.simpleFunctions:
+            #simple function: use only space if possible
+            assert len(
+                args) == 1, "Simple function %s must have 1 argument" % function
+            arg = args[0].__pretty__()
+            if arg.binding <= prettyForm.DIV:
+                #optimization: no parentheses necessary
+                return prettyForm(binding=prettyForm.FUNC, *arg.left(function + ' '))
+        argumentList = []
+        for arg in args:
+            argumentList.append(',')
+            argumentList.append(arg.__pretty__())
+        argumentList = stringPict(*stringPict.next(*argumentList[1:]))
+        argumentList = stringPict(*argumentList.parens())
+        return prettyForm(binding=prettyForm.ATOM, *argumentList.left(function))

lib/python3.12/site-packages/sympy/printing/tests/test_conventions.py

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

lib/python3.12/site-packages/sympy/printing/tests/test_gtk.py

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

lib/python3.12/site-packages/sympy/printing/tests/test_jax.py

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

lib/python3.12/site-packages/sympy/printing/tests/test_jscode.py

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

lib/python3.12/site-packages/sympy/printing/tests/test_julia.py

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

lib/python3.12/site-packages/sympy/printing/tests/test_llvmjit.py

@@ -0,0 +1,224 @@
+from sympy.external import import_module
+from sympy.testing.pytest import raises
+import ctypes
+
+
+if import_module('llvmlite'):
+    import sympy.printing.llvmjitcode as g
+else:
+    disabled = True
+
+import sympy
+from sympy.abc import a, b, n
+
+
+# copied from numpy.isclose documentation
+def isclose(a, b):
+    rtol = 1e-5
+    atol = 1e-8
+    return abs(a-b) <= atol + rtol*abs(b)
+
+
+def test_simple_expr():
+    e = a + 1.0
+    f = g.llvm_callable([a], e)
+    res = float(e.subs({a: 4.0}).evalf())
+    jit_res = f(4.0)
+
+    assert isclose(jit_res, res)
+
+
+def test_two_arg():
+    e = 4.0*a + b + 3.0
+    f = g.llvm_callable([a, b], e)
+    res = float(e.subs({a: 4.0, b: 3.0}).evalf())
+    jit_res = f(4.0, 3.0)
+
+    assert isclose(jit_res, res)
+
+
+def test_func():
+    e = 4.0*sympy.exp(-a)
+    f = g.llvm_callable([a], e)
+    res = float(e.subs({a: 1.5}).evalf())
+    jit_res = f(1.5)
+
+    assert isclose(jit_res, res)
+
+
+def test_two_func():
+    e = 4.0*sympy.exp(-a) + sympy.exp(b)
+    f = g.llvm_callable([a, b], e)
+    res = float(e.subs({a: 1.5, b: 2.0}).evalf())
+    jit_res = f(1.5, 2.0)
+
+    assert isclose(jit_res, res)
+
+
+def test_two_sqrt():
+    e = 4.0*sympy.sqrt(a) + sympy.sqrt(b)
+    f = g.llvm_callable([a, b], e)
+    res = float(e.subs({a: 1.5, b: 2.0}).evalf())
+    jit_res = f(1.5, 2.0)
+
+    assert isclose(jit_res, res)
+
+
+def test_two_pow():
+    e = a**1.5 + b**7
+    f = g.llvm_callable([a, b], e)
+    res = float(e.subs({a: 1.5, b: 2.0}).evalf())
+    jit_res = f(1.5, 2.0)
+
+    assert isclose(jit_res, res)
+
+
+def test_callback():
+    e = a + 1.2
+    f = g.llvm_callable([a], e, callback_type='scipy.integrate.test')
+    m = ctypes.c_int(1)
+    array_type = ctypes.c_double * 1
+    inp = {a: 2.2}
+    array = array_type(inp[a])
+    jit_res = f(m, array)
+
+    res = float(e.subs(inp).evalf())
+
+    assert isclose(jit_res, res)
+
+
+def test_callback_cubature():
+    e = a + 1.2
+    f = g.llvm_callable([a], e, callback_type='cubature')
+    m = ctypes.c_int(1)
+    array_type = ctypes.c_double * 1
+    inp = {a: 2.2}
+    array = array_type(inp[a])
+    out_array = array_type(0.0)
+    jit_ret = f(m, array, None, m, out_array)
+
+    assert jit_ret == 0
+
+    res = float(e.subs(inp).evalf())
+
+    assert isclose(out_array[0], res)
+
+
+def test_callback_two():
+    e = 3*a*b
+    f = g.llvm_callable([a, b], e, callback_type='scipy.integrate.test')
+    m = ctypes.c_int(2)
+    array_type = ctypes.c_double * 2
+    inp = {a: 0.2, b: 1.7}
+    array = array_type(inp[a], inp[b])
+    jit_res = f(m, array)
+
+    res = float(e.subs(inp).evalf())
+
+    assert isclose(jit_res, res)
+
+
+def test_callback_alt_two():
+    d = sympy.IndexedBase('d')
+    e = 3*d[0]*d[1]
+    f = g.llvm_callable([n, d], e, callback_type='scipy.integrate.test')
+    m = ctypes.c_int(2)
+    array_type = ctypes.c_double * 2
+    inp = {d[0]: 0.2, d[1]: 1.7}
+    array = array_type(inp[d[0]], inp[d[1]])
+    jit_res = f(m, array)
+
+    res = float(e.subs(inp).evalf())
+
+    assert isclose(jit_res, res)
+
+
+def test_multiple_statements():
+    # Match return from CSE
+    e = [[(b, 4.0*a)], [b + 5]]
+    f = g.llvm_callable([a], e)
+    b_val = e[0][0][1].subs({a: 1.5})
+    res = float(e[1][0].subs({b: b_val}).evalf())
+    jit_res = f(1.5)
+    assert isclose(jit_res, res)
+
+    f_callback = g.llvm_callable([a], e, callback_type='scipy.integrate.test')
+    m = ctypes.c_int(1)
+    array_type = ctypes.c_double * 1
+    array = array_type(1.5)
+    jit_callback_res = f_callback(m, array)
+    assert isclose(jit_callback_res, res)
+
+
+def test_cse():
+    e = a*a + b*b + sympy.exp(-a*a - b*b)
+    e2 = sympy.cse(e)
+    f = g.llvm_callable([a, b], e2)
+    res = float(e.subs({a: 2.3, b: 0.1}).evalf())
+    jit_res = f(2.3, 0.1)
+
+    assert isclose(jit_res, res)
+
+
+def eval_cse(e, sub_dict):
+    tmp_dict = {}
+    for tmp_name, tmp_expr in e[0]:
+        e2 = tmp_expr.subs(sub_dict)
+        e3 = e2.subs(tmp_dict)
+        tmp_dict[tmp_name] = e3
+    return [e.subs(sub_dict).subs(tmp_dict) for e in e[1]]
+
+
+def test_cse_multiple():
+    e1 = a*a
+    e2 = a*a + b*b
+    e3 = sympy.cse([e1, e2])
+
+    raises(NotImplementedError,
+           lambda: g.llvm_callable([a, b], e3, callback_type='scipy.integrate'))
+
+    f = g.llvm_callable([a, b], e3)
+    jit_res = f(0.1, 1.5)
+    assert len(jit_res) == 2
+    res = eval_cse(e3, {a: 0.1, b: 1.5})
+    assert isclose(res[0], jit_res[0])
+    assert isclose(res[1], jit_res[1])
+
+
+def test_callback_cubature_multiple():
+    e1 = a*a
+    e2 = a*a + b*b
+    e3 = sympy.cse([e1, e2, 4*e2])
+    f = g.llvm_callable([a, b], e3, callback_type='cubature')
+
+    # Number of input variables
+    ndim = 2
+    # Number of output expression values
+    outdim = 3
+
+    m = ctypes.c_int(ndim)
+    fdim = ctypes.c_int(outdim)
+    array_type = ctypes.c_double * ndim
+    out_array_type = ctypes.c_double * outdim
+    inp = {a: 0.2, b: 1.5}
+    array = array_type(inp[a], inp[b])
+    out_array = out_array_type()
+    jit_ret = f(m, array, None, fdim, out_array)
+
+    assert jit_ret == 0
+
+    res = eval_cse(e3, inp)
+
+    assert isclose(out_array[0], res[0])
+    assert isclose(out_array[1], res[1])
+    assert isclose(out_array[2], res[2])
+
+
+def test_symbol_not_found():
+    e = a*a + b
+    raises(LookupError, lambda: g.llvm_callable([a], e))
+
+
+def test_bad_callback():
+    e = a
+    raises(ValueError, lambda: g.llvm_callable([a], e, callback_type='bad_callback'))

lib/python3.12/site-packages/sympy/printing/tests/test_maple.py

@@ -0,0 +1,381 @@
+from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer,
+                        Tuple, Symbol, Eq, Ne, Le, Lt, Gt, Ge)
+from sympy.core import EulerGamma, GoldenRatio, Catalan, Lambda, Mul, Pow
+from sympy.functions import Piecewise, sqrt, ceiling, exp, sin, cos, sinc, lucas
+from sympy.testing.pytest import raises
+from sympy.utilities.lambdify import implemented_function
+from sympy.matrices import (eye, Matrix, MatrixSymbol, Identity,
+                            HadamardProduct, SparseMatrix)
+from sympy.functions.special.bessel import besseli
+
+from sympy.printing.maple import maple_code
+
+x, y, z = symbols('x,y,z')
+
+
+def test_Integer():
+    assert maple_code(Integer(67)) == "67"
+    assert maple_code(Integer(-1)) == "-1"
+
+
+def test_Rational():
+    assert maple_code(Rational(3, 7)) == "3/7"
+    assert maple_code(Rational(18, 9)) == "2"
+    assert maple_code(Rational(3, -7)) == "-3/7"
+    assert maple_code(Rational(-3, -7)) == "3/7"
+    assert maple_code(x + Rational(3, 7)) == "x + 3/7"
+    assert maple_code(Rational(3, 7) * x) == '(3/7)*x'
+
+
+def test_Relational():
+    assert maple_code(Eq(x, y)) == "x = y"
+    assert maple_code(Ne(x, y)) == "x <> y"
+    assert maple_code(Le(x, y)) == "x <= y"
+    assert maple_code(Lt(x, y)) == "x < y"
+    assert maple_code(Gt(x, y)) == "x > y"
+    assert maple_code(Ge(x, y)) == "x >= y"
+
+
+def test_Function():
+    assert maple_code(sin(x) ** cos(x)) == "sin(x)^cos(x)"
+    assert maple_code(abs(x)) == "abs(x)"
+    assert maple_code(ceiling(x)) == "ceil(x)"
+
+
+def test_Pow():
+    assert maple_code(x ** 3) == "x^3"
+    assert maple_code(x ** (y ** 3)) == "x^(y^3)"
+
+    assert maple_code((x ** 3) ** y) == "(x^3)^y"
+    assert maple_code(x ** Rational(2, 3)) == 'x^(2/3)'
+
+    g = implemented_function('g', Lambda(x, 2 * x))
+    assert maple_code(1 / (g(x) * 3.5) ** (x - y ** x) / (x ** 2 + y)) == \
+           "(3.5*2*x)^(-x + y^x)/(x^2 + y)"
+    # For issue 14160
+    assert maple_code(Mul(-2, x, Pow(Mul(y, y, evaluate=False), -1, evaluate=False),
+                          evaluate=False)) == '-2*x/(y*y)'
+
+
+def test_basic_ops():
+    assert maple_code(x * y) == "x*y"
+    assert maple_code(x + y) == "x + y"
+    assert maple_code(x - y) == "x - y"
+    assert maple_code(-x) == "-x"
+
+
+def test_1_over_x_and_sqrt():
+    # 1.0 and 0.5 would do something different in regular StrPrinter,
+    # but these are exact in IEEE floating point so no different here.
+    assert maple_code(1 / x) == '1/x'
+    assert maple_code(x ** -1) == maple_code(x ** -1.0) == '1/x'
+    assert maple_code(1 / sqrt(x)) == '1/sqrt(x)'
+    assert maple_code(x ** -S.Half) == maple_code(x ** -0.5) == '1/sqrt(x)'
+    assert maple_code(sqrt(x)) == 'sqrt(x)'
+    assert maple_code(x ** S.Half) == maple_code(x ** 0.5) == 'sqrt(x)'
+    assert maple_code(1 / pi) == '1/Pi'
+    assert maple_code(pi ** -1) == maple_code(pi ** -1.0) == '1/Pi'
+    assert maple_code(pi ** -0.5) == '1/sqrt(Pi)'
+
+
+def test_mix_number_mult_symbols():
+    assert maple_code(3 * x) == "3*x"
+    assert maple_code(pi * x) == "Pi*x"
+    assert maple_code(3 / x) == "3/x"
+    assert maple_code(pi / x) == "Pi/x"
+    assert maple_code(x / 3) == '(1/3)*x'
+    assert maple_code(x / pi) == "x/Pi"
+    assert maple_code(x * y) == "x*y"
+    assert maple_code(3 * x * y) == "3*x*y"
+    assert maple_code(3 * pi * x * y) == "3*Pi*x*y"
+    assert maple_code(x / y) == "x/y"
+    assert maple_code(3 * x / y) == "3*x/y"
+    assert maple_code(x * y / z) == "x*y/z"
+    assert maple_code(x / y * z) == "x*z/y"
+    assert maple_code(1 / x / y) == "1/(x*y)"
+    assert maple_code(2 * pi * x / y / z) == "2*Pi*x/(y*z)"
+    assert maple_code(3 * pi / x) == "3*Pi/x"
+    assert maple_code(S(3) / 5) == "3/5"
+    assert maple_code(S(3) / 5 * x) == '(3/5)*x'
+    assert maple_code(x / y / z) == "x/(y*z)"
+    assert maple_code((x + y) / z) == "(x + y)/z"
+    assert maple_code((x + y) / (z + x)) == "(x + y)/(x + z)"
+    assert maple_code((x + y) / EulerGamma) == '(x + y)/gamma'
+    assert maple_code(x / 3 / pi) == '(1/3)*x/Pi'
+    assert maple_code(S(3) / 5 * x * y / pi) == '(3/5)*x*y/Pi'
+
+
+def test_mix_number_pow_symbols():
+    assert maple_code(pi ** 3) == 'Pi^3'
+    assert maple_code(x ** 2) == 'x^2'
+
+    assert maple_code(x ** (pi ** 3)) == 'x^(Pi^3)'
+    assert maple_code(x ** y) == 'x^y'
+
+    assert maple_code(x ** (y ** z)) == 'x^(y^z)'
+    assert maple_code((x ** y) ** z) == '(x^y)^z'
+
+
+def test_imag():
+    I = S('I')
+    assert maple_code(I) == "I"
+    assert maple_code(5 * I) == "5*I"
+
+    assert maple_code((S(3) / 2) * I) == "(3/2)*I"
+    assert maple_code(3 + 4 * I) == "3 + 4*I"
+
+
+def test_constants():
+    assert maple_code(pi) == "Pi"
+    assert maple_code(oo) == "infinity"
+    assert maple_code(-oo) == "-infinity"
+    assert maple_code(S.NegativeInfinity) == "-infinity"
+    assert maple_code(S.NaN) == "undefined"
+    assert maple_code(S.Exp1) == "exp(1)"
+    assert maple_code(exp(1)) == "exp(1)"
+
+
+def test_constants_other():
+    assert maple_code(2 * GoldenRatio) == '2*(1/2 + (1/2)*sqrt(5))'
+    assert maple_code(2 * Catalan) == '2*Catalan'
+    assert maple_code(2 * EulerGamma) == "2*gamma"
+
+
+def test_boolean():
+    assert maple_code(x & y) == "x and y"
+    assert maple_code(x | y) == "x or y"
+    assert maple_code(~x) == "not x"
+    assert maple_code(x & y & z) == "x and y and z"
+    assert maple_code(x | y | z) == "x or y or z"
+    assert maple_code((x & y) | z) == "z or x and y"
+    assert maple_code((x | y) & z) == "z and (x or y)"
+
+
+def test_Matrices():
+    assert maple_code(Matrix(1, 1, [10])) == \
+           'Matrix([[10]], storage = rectangular)'
+
+    A = Matrix([[1, sin(x / 2), abs(x)],
+                [0, 1, pi],
+                [0, exp(1), ceiling(x)]])
+    expected = \
+        'Matrix(' \
+        '[[1, sin((1/2)*x), abs(x)],' \
+        ' [0, 1, Pi],' \
+        ' [0, exp(1), ceil(x)]], ' \
+        'storage = rectangular)'
+    assert maple_code(A) == expected
+
+    # row and columns
+    assert maple_code(A[:, 0]) == \
+           'Matrix([[1], [0], [0]], storage = rectangular)'
+    assert maple_code(A[0, :]) == \
+           'Matrix([[1, sin((1/2)*x), abs(x)]], storage = rectangular)'
+    assert maple_code(Matrix([[x, x - y, -y]])) == \
+           'Matrix([[x, x - y, -y]], storage = rectangular)'
+
+    # empty matrices
+    assert maple_code(Matrix(0, 0, [])) == \
+           'Matrix([], storage = rectangular)'
+    assert maple_code(Matrix(0, 3, [])) == \
+           'Matrix([], storage = rectangular)'
+
+def test_SparseMatrices():
+    assert maple_code(SparseMatrix(Identity(2))) == 'Matrix([[1, 0], [0, 1]], storage = sparse)'
+
+
+def test_vector_entries_hadamard():
+    # For a row or column, user might to use the other dimension
+    A = Matrix([[1, sin(2 / x), 3 * pi / x / 5]])
+    assert maple_code(A) == \
+           'Matrix([[1, sin(2/x), (3/5)*Pi/x]], storage = rectangular)'
+    assert maple_code(A.T) == \
+           'Matrix([[1], [sin(2/x)], [(3/5)*Pi/x]], storage = rectangular)'
+
+
+def test_Matrices_entries_not_hadamard():
+    A = Matrix([[1, sin(2 / x), 3 * pi / x / 5], [1, 2, x * y]])
+    expected = \
+        'Matrix([[1, sin(2/x), (3/5)*Pi/x], [1, 2, x*y]], ' \
+        'storage = rectangular)'
+    assert maple_code(A) == expected
+
+
+def test_MatrixSymbol():
+    n = Symbol('n', integer=True)
+    A = MatrixSymbol('A', n, n)
+    B = MatrixSymbol('B', n, n)
+    assert maple_code(A * B) == "A.B"
+    assert maple_code(B * A) == "B.A"
+    assert maple_code(2 * A * B) == "2*A.B"
+    assert maple_code(B * 2 * A) == "2*B.A"
+
+    assert maple_code(
+        A * (B + 3 * Identity(n))) == "A.(3*Matrix(n, shape = identity) + B)"
+
+    assert maple_code(A ** (x ** 2)) == "MatrixPower(A, x^2)"
+    assert maple_code(A ** 3) == "MatrixPower(A, 3)"
+    assert maple_code(A ** (S.Half)) == "MatrixPower(A, 1/2)"
+
+
+def test_special_matrices():
+    assert maple_code(6 * Identity(3)) == "6*Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], storage = sparse)"
+    assert maple_code(Identity(x)) == 'Matrix(x, shape = identity)'
+
+
+def test_containers():
+    assert maple_code([1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]) == \
+           "[1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]"
+
+    assert maple_code((1, 2, (3, 4))) == "[1, 2, [3, 4]]"
+    assert maple_code([1]) == "[1]"
+    assert maple_code((1,)) == "[1]"
+    assert maple_code(Tuple(*[1, 2, 3])) == "[1, 2, 3]"
+    assert maple_code((1, x * y, (3, x ** 2))) == "[1, x*y, [3, x^2]]"
+    # scalar, matrix, empty matrix and empty list
+
+    assert maple_code((1, eye(3), Matrix(0, 0, []), [])) == \
+           "[1, Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], storage = rectangular), Matrix([], storage = rectangular), []]"
+
+
+def test_maple_noninline():
+    source = maple_code((x + y)/Catalan, assign_to='me', inline=False)
+    expected = "me := (x + y)/Catalan"
+
+    assert source == expected
+
+
+def test_maple_matrix_assign_to():
+    A = Matrix([[1, 2, 3]])
+    assert maple_code(A, assign_to='a') == "a := Matrix([[1, 2, 3]], storage = rectangular)"
+    A = Matrix([[1, 2], [3, 4]])
+    assert maple_code(A, assign_to='A') == "A := Matrix([[1, 2], [3, 4]], storage = rectangular)"
+
+
+def test_maple_matrix_assign_to_more():
+    # assigning to Symbol or MatrixSymbol requires lhs/rhs match
+    A = Matrix([[1, 2, 3]])
+    B = MatrixSymbol('B', 1, 3)
+    C = MatrixSymbol('C', 2, 3)
+    assert maple_code(A, assign_to=B) == "B := Matrix([[1, 2, 3]], storage = rectangular)"
+    raises(ValueError, lambda: maple_code(A, assign_to=x))
+    raises(ValueError, lambda: maple_code(A, assign_to=C))
+
+
+def test_maple_matrix_1x1():
+    A = Matrix([[3]])
+    assert maple_code(A, assign_to='B') == "B := Matrix([[3]], storage = rectangular)"
+
+
+def test_maple_matrix_elements():
+    A = Matrix([[x, 2, x * y]])
+
+    assert maple_code(A[0, 0] ** 2 + A[0, 1] + A[0, 2]) == "x^2 + x*y + 2"
+    AA = MatrixSymbol('AA', 1, 3)
+    assert maple_code(AA) == "AA"
+
+    assert maple_code(AA[0, 0] ** 2 + sin(AA[0, 1]) + AA[0, 2]) == \
+           "sin(AA[1, 2]) + AA[1, 1]^2 + AA[1, 3]"
+    assert maple_code(sum(AA)) == "AA[1, 1] + AA[1, 2] + AA[1, 3]"
+
+
+def test_maple_boolean():
+    assert maple_code(True) == "true"
+    assert maple_code(S.true) == "true"
+    assert maple_code(False) == "false"
+    assert maple_code(S.false) == "false"
+
+
+def test_sparse():
+    M = SparseMatrix(5, 6, {})
+    M[2, 2] = 10
+    M[1, 2] = 20
+    M[1, 3] = 22
+    M[0, 3] = 30
+    M[3, 0] = x * y
+    assert maple_code(M) == \
+           'Matrix([[0, 0, 0, 30, 0, 0],' \
+           ' [0, 0, 20, 22, 0, 0],' \
+           ' [0, 0, 10, 0, 0, 0],' \
+           ' [x*y, 0, 0, 0, 0, 0],' \
+           ' [0, 0, 0, 0, 0, 0]], ' \
+           'storage = sparse)'
+
+# Not an important point.
+def test_maple_not_supported():
+    with raises(NotImplementedError):
+        maple_code(S.ComplexInfinity)
+
+
+def test_MatrixElement_printing():
+    # test cases for issue #11821
+    A = MatrixSymbol("A", 1, 3)
+    B = MatrixSymbol("B", 1, 3)
+
+    assert (maple_code(A[0, 0]) == "A[1, 1]")
+    assert (maple_code(3 * A[0, 0]) == "3*A[1, 1]")
+
+    F = A-B
+
+    assert (maple_code(F[0,0]) == "A[1, 1] - B[1, 1]")
+
+
+def test_hadamard():
+    A = MatrixSymbol('A', 3, 3)
+    B = MatrixSymbol('B', 3, 3)
+    v = MatrixSymbol('v', 3, 1)
+    h = MatrixSymbol('h', 1, 3)
+    C = HadamardProduct(A, B)
+    assert maple_code(C) == "A*B"
+
+    assert maple_code(C * v) == "(A*B).v"
+    # HadamardProduct is higher than dot product.
+
+    assert maple_code(h * C * v) == "h.(A*B).v"
+
+    assert maple_code(C * A) == "(A*B).A"
+    # mixing Hadamard and scalar strange b/c we vectorize scalars
+
+    assert maple_code(C * x * y) == "x*y*(A*B)"
+
+
+def test_maple_piecewise():
+    expr = Piecewise((x, x < 1), (x ** 2, True))
+
+    assert maple_code(expr) == "piecewise(x < 1, x, x^2)"
+    assert maple_code(expr, assign_to="r") == (
+        "r := piecewise(x < 1, x, x^2)")
+
+    expr = Piecewise((x ** 2, x < 1), (x ** 3, x < 2), (x ** 4, x < 3), (x ** 5, True))
+    expected = "piecewise(x < 1, x^2, x < 2, x^3, x < 3, x^4, x^5)"
+    assert maple_code(expr) == expected
+    assert maple_code(expr, assign_to="r") == "r := " + expected
+
+    # Check that Piecewise without a True (default) condition error
+    expr = Piecewise((x, x < 1), (x ** 2, x > 1), (sin(x), x > 0))
+    raises(ValueError, lambda: maple_code(expr))
+
+
+def test_maple_piecewise_times_const():
+    pw = Piecewise((x, x < 1), (x ** 2, True))
+
+    assert maple_code(2 * pw) == "2*piecewise(x < 1, x, x^2)"
+    assert maple_code(pw / x) == "piecewise(x < 1, x, x^2)/x"
+    assert maple_code(pw / (x * y)) == "piecewise(x < 1, x, x^2)/(x*y)"
+    assert maple_code(pw / 3) == "(1/3)*piecewise(x < 1, x, x^2)"
+
+
+def test_maple_derivatives():
+    f = Function('f')
+    assert maple_code(f(x).diff(x)) == 'diff(f(x), x)'
+    assert maple_code(f(x).diff(x, 2)) == 'diff(f(x), x$2)'
+
+
+def test_automatic_rewrites():
+    assert maple_code(lucas(x)) == '(2^(-x)*((1 - sqrt(5))^x + (1 + sqrt(5))^x))'
+    assert maple_code(sinc(x)) == '(piecewise(x <> 0, sin(x)/x, 1))'
+
+
+def test_specfun():
+    assert maple_code('asin(x)') == 'arcsin(x)'
+    assert maple_code(besseli(x, y)) == 'BesselI(x, y)'

lib/python3.12/site-packages/sympy/printing/tests/test_mathematica.py

@@ -0,0 +1,287 @@
+from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer, Tuple,
+                        Derivative, Eq, Ne, Le, Lt, Gt, Ge)
+from sympy.integrals import Integral
+from sympy.concrete import Sum
+from sympy.functions import (exp, sin, cos, fresnelc, fresnels, conjugate, Max,
+                             Min, gamma, polygamma, loggamma, erf, erfi, erfc,
+                             erf2, expint, erfinv, erfcinv, Ei, Si, Ci, li,
+                             Shi, Chi, uppergamma, beta, subfactorial, erf2inv,
+                             factorial, factorial2, catalan, RisingFactorial,
+                             FallingFactorial, harmonic, atan2, sec, acsc,
+                             hermite, laguerre, assoc_laguerre, jacobi,
+                             gegenbauer, chebyshevt, chebyshevu, legendre,
+                             assoc_legendre, Li, LambertW)
+
+from sympy.printing.mathematica import mathematica_code as mcode
+
+x, y, z, w = symbols('x,y,z,w')
+f = Function('f')
+
+
+def test_Integer():
+    assert mcode(Integer(67)) == "67"
+    assert mcode(Integer(-1)) == "-1"
+
+
+def test_Rational():
+    assert mcode(Rational(3, 7)) == "3/7"
+    assert mcode(Rational(18, 9)) == "2"
+    assert mcode(Rational(3, -7)) == "-3/7"
+    assert mcode(Rational(-3, -7)) == "3/7"
+    assert mcode(x + Rational(3, 7)) == "x + 3/7"
+    assert mcode(Rational(3, 7)*x) == "(3/7)*x"
+
+
+def test_Relational():
+    assert mcode(Eq(x, y)) == "x == y"
+    assert mcode(Ne(x, y)) == "x != y"
+    assert mcode(Le(x, y)) == "x <= y"
+    assert mcode(Lt(x, y)) == "x < y"
+    assert mcode(Gt(x, y)) == "x > y"
+    assert mcode(Ge(x, y)) == "x >= y"
+
+
+def test_Function():
+    assert mcode(f(x, y, z)) == "f[x, y, z]"
+    assert mcode(sin(x) ** cos(x)) == "Sin[x]^Cos[x]"
+    assert mcode(sec(x) * acsc(x)) == "ArcCsc[x]*Sec[x]"
+    assert mcode(atan2(x, y)) == "ArcTan[x, y]"
+    assert mcode(conjugate(x)) == "Conjugate[x]"
+    assert mcode(Max(x, y, z)*Min(y, z)) == "Max[x, y, z]*Min[y, z]"
+    assert mcode(fresnelc(x)) == "FresnelC[x]"
+    assert mcode(fresnels(x)) == "FresnelS[x]"
+    assert mcode(gamma(x)) == "Gamma[x]"
+    assert mcode(uppergamma(x, y)) == "Gamma[x, y]"
+    assert mcode(polygamma(x, y)) == "PolyGamma[x, y]"
+    assert mcode(loggamma(x)) == "LogGamma[x]"
+    assert mcode(erf(x)) == "Erf[x]"
+    assert mcode(erfc(x)) == "Erfc[x]"
+    assert mcode(erfi(x)) == "Erfi[x]"
+    assert mcode(erf2(x, y)) == "Erf[x, y]"
+    assert mcode(expint(x, y)) == "ExpIntegralE[x, y]"
+    assert mcode(erfcinv(x)) == "InverseErfc[x]"
+    assert mcode(erfinv(x)) == "InverseErf[x]"
+    assert mcode(erf2inv(x, y)) == "InverseErf[x, y]"
+    assert mcode(Ei(x)) == "ExpIntegralEi[x]"
+    assert mcode(Ci(x)) == "CosIntegral[x]"
+    assert mcode(li(x)) == "LogIntegral[x]"
+    assert mcode(Si(x)) == "SinIntegral[x]"
+    assert mcode(Shi(x)) == "SinhIntegral[x]"
+    assert mcode(Chi(x)) == "CoshIntegral[x]"
+    assert mcode(beta(x, y)) == "Beta[x, y]"
+    assert mcode(factorial(x)) == "Factorial[x]"
+    assert mcode(factorial2(x)) == "Factorial2[x]"
+    assert mcode(subfactorial(x)) == "Subfactorial[x]"
+    assert mcode(FallingFactorial(x, y)) == "FactorialPower[x, y]"
+    assert mcode(RisingFactorial(x, y)) == "Pochhammer[x, y]"
+    assert mcode(catalan(x)) == "CatalanNumber[x]"
+    assert mcode(harmonic(x)) == "HarmonicNumber[x]"
+    assert mcode(harmonic(x, y)) == "HarmonicNumber[x, y]"
+    assert mcode(Li(x)) == "LogIntegral[x] - LogIntegral[2]"
+    assert mcode(LambertW(x)) == "ProductLog[x]"
+    assert mcode(LambertW(x, -1)) == "ProductLog[-1, x]"
+    assert mcode(LambertW(x, y)) == "ProductLog[y, x]"
+
+
+def test_special_polynomials():
+    assert mcode(hermite(x, y)) == "HermiteH[x, y]"
+    assert mcode(laguerre(x, y)) == "LaguerreL[x, y]"
+    assert mcode(assoc_laguerre(x, y, z)) == "LaguerreL[x, y, z]"
+    assert mcode(jacobi(x, y, z, w)) == "JacobiP[x, y, z, w]"
+    assert mcode(gegenbauer(x, y, z)) == "GegenbauerC[x, y, z]"
+    assert mcode(chebyshevt(x, y)) == "ChebyshevT[x, y]"
+    assert mcode(chebyshevu(x, y)) == "ChebyshevU[x, y]"
+    assert mcode(legendre(x, y)) == "LegendreP[x, y]"
+    assert mcode(assoc_legendre(x, y, z)) == "LegendreP[x, y, z]"
+
+
+def test_Pow():
+    assert mcode(x**3) == "x^3"
+    assert mcode(x**(y**3)) == "x^(y^3)"
+    assert mcode(1/(f(x)*3.5)**(x - y**x)/(x**2 + y)) == \
+        "(3.5*f[x])^(-x + y^x)/(x^2 + y)"
+    assert mcode(x**-1.0) == 'x^(-1.0)'
+    assert mcode(x**Rational(2, 3)) == 'x^(2/3)'
+
+
+def test_Mul():
+    A, B, C, D = symbols('A B C D', commutative=False)
+    assert mcode(x*y*z) == "x*y*z"
+    assert mcode(x*y*A) == "x*y*A"
+    assert mcode(x*y*A*B) == "x*y*A**B"
+    assert mcode(x*y*A*B*C) == "x*y*A**B**C"
+    assert mcode(x*A*B*(C + D)*A*y) == "x*y*A**B**(C + D)**A"
+
+
+def test_constants():
+    assert mcode(S.Zero) == "0"
+    assert mcode(S.One) == "1"
+    assert mcode(S.NegativeOne) == "-1"
+    assert mcode(S.Half) == "1/2"
+    assert mcode(S.ImaginaryUnit) == "I"
+
+    assert mcode(oo) == "Infinity"
+    assert mcode(S.NegativeInfinity) == "-Infinity"
+    assert mcode(S.ComplexInfinity) == "ComplexInfinity"
+    assert mcode(S.NaN) == "Indeterminate"
+
+    assert mcode(S.Exp1) == "E"
+    assert mcode(pi) == "Pi"
+    assert mcode(S.GoldenRatio) == "GoldenRatio"
+    assert mcode(S.TribonacciConstant) == \
+        "(1/3 + (1/3)*(19 - 3*33^(1/2))^(1/3) + " \
+        "(1/3)*(3*33^(1/2) + 19)^(1/3))"
+    assert mcode(2*S.TribonacciConstant) == \
+        "2*(1/3 + (1/3)*(19 - 3*33^(1/2))^(1/3) + " \
+        "(1/3)*(3*33^(1/2) + 19)^(1/3))"
+    assert mcode(S.EulerGamma) == "EulerGamma"
+    assert mcode(S.Catalan) == "Catalan"
+
+
+def test_containers():
+    assert mcode([1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]) == \
+        "{1, 2, 3, {4, 5, {6, 7}}, 8, {9, 10}, 11}"
+    assert mcode((1, 2, (3, 4))) == "{1, 2, {3, 4}}"
+    assert mcode([1]) == "{1}"
+    assert mcode((1,)) == "{1}"
+    assert mcode(Tuple(*[1, 2, 3])) == "{1, 2, 3}"
+
+
+def test_matrices():
+    from sympy.matrices import MutableDenseMatrix, MutableSparseMatrix, \
+        ImmutableDenseMatrix, ImmutableSparseMatrix
+    A = MutableDenseMatrix(
+        [[1, -1, 0, 0],
+         [0, 1, -1, 0],
+         [0, 0, 1, -1],
+         [0, 0, 0, 1]]
+    )
+    B = MutableSparseMatrix(A)
+    C = ImmutableDenseMatrix(A)
+    D = ImmutableSparseMatrix(A)
+
+    assert mcode(C) == mcode(A) == \
+        "{{1, -1, 0, 0}, " \
+        "{0, 1, -1, 0}, " \
+        "{0, 0, 1, -1}, " \
+        "{0, 0, 0, 1}}"
+
+    assert mcode(D) == mcode(B) == \
+        "SparseArray[{" \
+        "{1, 1} -> 1, {1, 2} -> -1, {2, 2} -> 1, {2, 3} -> -1, " \
+        "{3, 3} -> 1, {3, 4} -> -1, {4, 4} -> 1" \
+        "}, {4, 4}]"
+
+    # Trivial cases of matrices
+    assert mcode(MutableDenseMatrix(0, 0, [])) == '{}'
+    assert mcode(MutableSparseMatrix(0, 0, [])) == 'SparseArray[{}, {0, 0}]'
+    assert mcode(MutableDenseMatrix(0, 3, [])) == '{}'
+    assert mcode(MutableSparseMatrix(0, 3, [])) == 'SparseArray[{}, {0, 3}]'
+    assert mcode(MutableDenseMatrix(3, 0, [])) == '{{}, {}, {}}'
+    assert mcode(MutableSparseMatrix(3, 0, [])) == 'SparseArray[{}, {3, 0}]'
+
+def test_NDArray():
+    from sympy.tensor.array import (
+        MutableDenseNDimArray, ImmutableDenseNDimArray,
+        MutableSparseNDimArray, ImmutableSparseNDimArray)
+
+    example = MutableDenseNDimArray(
+        [[[1, 2, 3, 4],
+          [5, 6, 7, 8],
+          [9, 10, 11, 12]],
+         [[13, 14, 15, 16],
+          [17, 18, 19, 20],
+          [21, 22, 23, 24]]]
+    )
+
+    assert mcode(example) == \
+    "{{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}, " \
+    "{{13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24}}}"
+
+    example = ImmutableDenseNDimArray(example)
+
+    assert mcode(example) == \
+    "{{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}, " \
+    "{{13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24}}}"
+
+    example = MutableSparseNDimArray(example)
+
+    assert mcode(example) == \
+    "SparseArray[{" \
+        "{1, 1, 1} -> 1, {1, 1, 2} -> 2, {1, 1, 3} -> 3, " \
+        "{1, 1, 4} -> 4, {1, 2, 1} -> 5, {1, 2, 2} -> 6, " \
+        "{1, 2, 3} -> 7, {1, 2, 4} -> 8, {1, 3, 1} -> 9, " \
+        "{1, 3, 2} -> 10, {1, 3, 3} -> 11, {1, 3, 4} -> 12, " \
+        "{2, 1, 1} -> 13, {2, 1, 2} -> 14, {2, 1, 3} -> 15, " \
+        "{2, 1, 4} -> 16, {2, 2, 1} -> 17, {2, 2, 2} -> 18, " \
+        "{2, 2, 3} -> 19, {2, 2, 4} -> 20, {2, 3, 1} -> 21, " \
+        "{2, 3, 2} -> 22, {2, 3, 3} -> 23, {2, 3, 4} -> 24" \
+        "}, {2, 3, 4}]"
+
+    example = ImmutableSparseNDimArray(example)
+
+    assert mcode(example) == \
+    "SparseArray[{" \
+        "{1, 1, 1} -> 1, {1, 1, 2} -> 2, {1, 1, 3} -> 3, " \
+        "{1, 1, 4} -> 4, {1, 2, 1} -> 5, {1, 2, 2} -> 6, " \
+        "{1, 2, 3} -> 7, {1, 2, 4} -> 8, {1, 3, 1} -> 9, " \
+        "{1, 3, 2} -> 10, {1, 3, 3} -> 11, {1, 3, 4} -> 12, " \
+        "{2, 1, 1} -> 13, {2, 1, 2} -> 14, {2, 1, 3} -> 15, " \
+        "{2, 1, 4} -> 16, {2, 2, 1} -> 17, {2, 2, 2} -> 18, " \
+        "{2, 2, 3} -> 19, {2, 2, 4} -> 20, {2, 3, 1} -> 21, " \
+        "{2, 3, 2} -> 22, {2, 3, 3} -> 23, {2, 3, 4} -> 24" \
+        "}, {2, 3, 4}]"
+
+
+def test_Integral():
+    assert mcode(Integral(sin(sin(x)), x)) == "Hold[Integrate[Sin[Sin[x]], x]]"
+    assert mcode(Integral(exp(-x**2 - y**2),
+                          (x, -oo, oo),
+                          (y, -oo, oo))) == \
+        "Hold[Integrate[Exp[-x^2 - y^2], {x, -Infinity, Infinity}, " \
+        "{y, -Infinity, Infinity}]]"
+
+
+def test_Derivative():
+    assert mcode(Derivative(sin(x), x)) == "Hold[D[Sin[x], x]]"
+    assert mcode(Derivative(x, x)) == "Hold[D[x, x]]"
+    assert mcode(Derivative(sin(x)*y**4, x, 2)) == "Hold[D[y^4*Sin[x], {x, 2}]]"
+    assert mcode(Derivative(sin(x)*y**4, x, y, x)) == "Hold[D[y^4*Sin[x], x, y, x]]"
+    assert mcode(Derivative(sin(x)*y**4, x, y, 3, x)) == "Hold[D[y^4*Sin[x], x, {y, 3}, x]]"
+
+
+def test_Sum():
+    assert mcode(Sum(sin(x), (x, 0, 10))) == "Hold[Sum[Sin[x], {x, 0, 10}]]"
+    assert mcode(Sum(exp(-x**2 - y**2),
+                     (x, -oo, oo),
+                     (y, -oo, oo))) == \
+        "Hold[Sum[Exp[-x^2 - y^2], {x, -Infinity, Infinity}, " \
+        "{y, -Infinity, Infinity}]]"
+
+
+def test_comment():
+    from sympy.printing.mathematica import MCodePrinter
+    assert MCodePrinter()._get_comment("Hello World") == \
+        "(* Hello World *)"
+
+
+def test_userfuncs():
+    # Dictionary mutation test
+    some_function = symbols("some_function", cls=Function)
+    my_user_functions = {"some_function": "SomeFunction"}
+    assert mcode(
+        some_function(z),
+        user_functions=my_user_functions) == \
+        'SomeFunction[z]'
+    assert mcode(
+        some_function(z),
+        user_functions=my_user_functions) == \
+        'SomeFunction[z]'
+
+    # List argument test
+    my_user_functions = \
+        {"some_function": [(lambda x: True, "SomeOtherFunction")]}
+    assert mcode(
+        some_function(z),
+        user_functions=my_user_functions) == \
+        'SomeOtherFunction[z]'

lib/python3.12/site-packages/sympy/printing/tests/test_octave.py

@@ -0,0 +1,515 @@
+from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer,
+                        Tuple, Symbol, EulerGamma, GoldenRatio, Catalan,
+                        Lambda, Mul, Pow, Mod, Eq, Ne, Le, Lt, Gt, Ge)
+from sympy.codegen.matrix_nodes import MatrixSolve
+from sympy.functions import (arg, atan2, bernoulli, beta, ceiling, chebyshevu,
+                             chebyshevt, conjugate, DiracDelta, exp, expint,
+                             factorial, floor, harmonic, Heaviside, im,
+                             laguerre, LambertW, log, Max, Min, Piecewise,
+                             polylog, re, RisingFactorial, sign, sinc, sqrt,
+                             zeta, binomial, legendre, dirichlet_eta,
+                             riemann_xi)
+from sympy.functions import (sin, cos, tan, cot, sec, csc, asin, acos, acot,
+                             atan, asec, acsc, sinh, cosh, tanh, coth, csch,
+                             sech, asinh, acosh, atanh, acoth, asech, acsch)
+from sympy.testing.pytest import raises, XFAIL
+from sympy.utilities.lambdify import implemented_function
+from sympy.matrices import (eye, Matrix, MatrixSymbol, Identity,
+                            HadamardProduct, SparseMatrix, HadamardPower)
+from sympy.functions.special.bessel import (jn, yn, besselj, bessely, besseli,
+                                            besselk, hankel1, hankel2, airyai,
+                                            airybi, airyaiprime, airybiprime)
+from sympy.functions.special.gamma_functions import (gamma, lowergamma,
+                                                     uppergamma, loggamma,
+                                                     polygamma)
+from sympy.functions.special.error_functions import (Chi, Ci, erf, erfc, erfi,
+                                                     erfcinv, erfinv, fresnelc,
+                                                     fresnels, li, Shi, Si, Li,
+                                                     erf2, Ei)
+from sympy.printing.octave import octave_code, octave_code as mcode
+
+x, y, z = symbols('x,y,z')
+
+
+def test_Integer():
+    assert mcode(Integer(67)) == "67"
+    assert mcode(Integer(-1)) == "-1"
+
+
+def test_Rational():
+    assert mcode(Rational(3, 7)) == "3/7"
+    assert mcode(Rational(18, 9)) == "2"
+    assert mcode(Rational(3, -7)) == "-3/7"
+    assert mcode(Rational(-3, -7)) == "3/7"
+    assert mcode(x + Rational(3, 7)) == "x + 3/7"
+    assert mcode(Rational(3, 7)*x) == "3*x/7"
+
+
+def test_Relational():
+    assert mcode(Eq(x, y)) == "x == y"
+    assert mcode(Ne(x, y)) == "x != y"
+    assert mcode(Le(x, y)) == "x <= y"
+    assert mcode(Lt(x, y)) == "x < y"
+    assert mcode(Gt(x, y)) == "x > y"
+    assert mcode(Ge(x, y)) == "x >= y"
+
+
+def test_Function():
+    assert mcode(sin(x) ** cos(x)) == "sin(x).^cos(x)"
+    assert mcode(sign(x)) == "sign(x)"
+    assert mcode(exp(x)) == "exp(x)"
+    assert mcode(log(x)) == "log(x)"
+    assert mcode(factorial(x)) == "factorial(x)"
+    assert mcode(floor(x)) == "floor(x)"
+    assert mcode(atan2(y, x)) == "atan2(y, x)"
+    assert mcode(beta(x, y)) == 'beta(x, y)'
+    assert mcode(polylog(x, y)) == 'polylog(x, y)'
+    assert mcode(harmonic(x)) == 'harmonic(x)'
+    assert mcode(bernoulli(x)) == "bernoulli(x)"
+    assert mcode(bernoulli(x, y)) == "bernoulli(x, y)"
+    assert mcode(legendre(x, y)) == "legendre(x, y)"
+
+
+def test_Function_change_name():
+    assert mcode(abs(x)) == "abs(x)"
+    assert mcode(ceiling(x)) == "ceil(x)"
+    assert mcode(arg(x)) == "angle(x)"
+    assert mcode(im(x)) == "imag(x)"
+    assert mcode(re(x)) == "real(x)"
+    assert mcode(conjugate(x)) == "conj(x)"
+    assert mcode(chebyshevt(y, x)) == "chebyshevT(y, x)"
+    assert mcode(chebyshevu(y, x)) == "chebyshevU(y, x)"
+    assert mcode(laguerre(x, y)) == "laguerreL(x, y)"
+    assert mcode(Chi(x)) == "coshint(x)"
+    assert mcode(Shi(x)) ==  "sinhint(x)"
+    assert mcode(Ci(x)) == "cosint(x)"
+    assert mcode(Si(x)) ==  "sinint(x)"
+    assert mcode(li(x)) ==  "logint(x)"
+    assert mcode(loggamma(x)) ==  "gammaln(x)"
+    assert mcode(polygamma(x, y)) == "psi(x, y)"
+    assert mcode(RisingFactorial(x, y)) == "pochhammer(x, y)"
+    assert mcode(DiracDelta(x)) == "dirac(x)"
+    assert mcode(DiracDelta(x, 3)) == "dirac(3, x)"
+    assert mcode(Heaviside(x)) == "heaviside(x, 1/2)"
+    assert mcode(Heaviside(x, y)) == "heaviside(x, y)"
+    assert mcode(binomial(x, y)) == "bincoeff(x, y)"
+    assert mcode(Mod(x, y)) == "mod(x, y)"
+
+
+def test_minmax():
+    assert mcode(Max(x, y) + Min(x, y)) == "max(x, y) + min(x, y)"
+    assert mcode(Max(x, y, z)) == "max(x, max(y, z))"
+    assert mcode(Min(x, y, z)) == "min(x, min(y, z))"
+
+
+def test_Pow():
+    assert mcode(x**3) == "x.^3"
+    assert mcode(x**(y**3)) == "x.^(y.^3)"
+    assert mcode(x**Rational(2, 3)) == 'x.^(2/3)'
+    g = implemented_function('g', Lambda(x, 2*x))
+    assert mcode(1/(g(x)*3.5)**(x - y**x)/(x**2 + y)) == \
+        "(3.5*2*x).^(-x + y.^x)./(x.^2 + y)"
+    # For issue 14160
+    assert mcode(Mul(-2, x, Pow(Mul(y,y,evaluate=False), -1, evaluate=False),
+                                                evaluate=False)) == '-2*x./(y.*y)'
+
+
+def test_basic_ops():
+    assert mcode(x*y) == "x.*y"
+    assert mcode(x + y) == "x + y"
+    assert mcode(x - y) == "x - y"
+    assert mcode(-x) == "-x"
+
+
+def test_1_over_x_and_sqrt():
+    # 1.0 and 0.5 would do something different in regular StrPrinter,
+    # but these are exact in IEEE floating point so no different here.
+    assert mcode(1/x) == '1./x'
+    assert mcode(x**-1) == mcode(x**-1.0) == '1./x'
+    assert mcode(1/sqrt(x)) == '1./sqrt(x)'
+    assert mcode(x**-S.Half) == mcode(x**-0.5) == '1./sqrt(x)'
+    assert mcode(sqrt(x)) == 'sqrt(x)'
+    assert mcode(x**S.Half) == mcode(x**0.5) == 'sqrt(x)'
+    assert mcode(1/pi) == '1/pi'
+    assert mcode(pi**-1) == mcode(pi**-1.0) == '1/pi'
+    assert mcode(pi**-0.5) == '1/sqrt(pi)'
+
+
+def test_mix_number_mult_symbols():
+    assert mcode(3*x) == "3*x"
+    assert mcode(pi*x) == "pi*x"
+    assert mcode(3/x) == "3./x"
+    assert mcode(pi/x) == "pi./x"
+    assert mcode(x/3) == "x/3"
+    assert mcode(x/pi) == "x/pi"
+    assert mcode(x*y) == "x.*y"
+    assert mcode(3*x*y) == "3*x.*y"
+    assert mcode(3*pi*x*y) == "3*pi*x.*y"
+    assert mcode(x/y) == "x./y"
+    assert mcode(3*x/y) == "3*x./y"
+    assert mcode(x*y/z) == "x.*y./z"
+    assert mcode(x/y*z) == "x.*z./y"
+    assert mcode(1/x/y) == "1./(x.*y)"
+    assert mcode(2*pi*x/y/z) == "2*pi*x./(y.*z)"
+    assert mcode(3*pi/x) == "3*pi./x"
+    assert mcode(S(3)/5) == "3/5"
+    assert mcode(S(3)/5*x) == "3*x/5"
+    assert mcode(x/y/z) == "x./(y.*z)"
+    assert mcode((x+y)/z) == "(x + y)./z"
+    assert mcode((x+y)/(z+x)) == "(x + y)./(x + z)"
+    assert mcode((x+y)/EulerGamma) == "(x + y)/%s" % EulerGamma.evalf(17)
+    assert mcode(x/3/pi) == "x/(3*pi)"
+    assert mcode(S(3)/5*x*y/pi) == "3*x.*y/(5*pi)"
+
+
+def test_mix_number_pow_symbols():
+    assert mcode(pi**3) == 'pi^3'
+    assert mcode(x**2) == 'x.^2'
+    assert mcode(x**(pi**3)) == 'x.^(pi^3)'
+    assert mcode(x**y) == 'x.^y'
+    assert mcode(x**(y**z)) == 'x.^(y.^z)'
+    assert mcode((x**y)**z) == '(x.^y).^z'
+
+
+def test_imag():
+    I = S('I')
+    assert mcode(I) == "1i"
+    assert mcode(5*I) == "5i"
+    assert mcode((S(3)/2)*I) == "3*1i/2"
+    assert mcode(3+4*I) == "3 + 4i"
+    assert mcode(sqrt(3)*I) == "sqrt(3)*1i"
+
+
+def test_constants():
+    assert mcode(pi) == "pi"
+    assert mcode(oo) == "inf"
+    assert mcode(-oo) == "-inf"
+    assert mcode(S.NegativeInfinity) == "-inf"
+    assert mcode(S.NaN) == "NaN"
+    assert mcode(S.Exp1) == "exp(1)"
+    assert mcode(exp(1)) == "exp(1)"
+
+
+def test_constants_other():
+    assert mcode(2*GoldenRatio) == "2*(1+sqrt(5))/2"
+    assert mcode(2*Catalan) == "2*%s" % Catalan.evalf(17)
+    assert mcode(2*EulerGamma) == "2*%s" % EulerGamma.evalf(17)
+
+
+def test_boolean():
+    assert mcode(x & y) == "x & y"
+    assert mcode(x | y) == "x | y"
+    assert mcode(~x) == "~x"
+    assert mcode(x & y & z) == "x & y & z"
+    assert mcode(x | y | z) == "x | y | z"
+    assert mcode((x & y) | z) == "z | x & y"
+    assert mcode((x | y) & z) == "z & (x | y)"
+
+
+def test_KroneckerDelta():
+    from sympy.functions import KroneckerDelta
+    assert mcode(KroneckerDelta(x, y)) == "double(x == y)"
+    assert mcode(KroneckerDelta(x, y + 1)) == "double(x == (y + 1))"
+    assert mcode(KroneckerDelta(2**x, y)) == "double((2.^x) == y)"
+
+
+def test_Matrices():
+    assert mcode(Matrix(1, 1, [10])) == "10"
+    A = Matrix([[1, sin(x/2), abs(x)],
+                [0, 1, pi],
+                [0, exp(1), ceiling(x)]]);
+    expected = "[1 sin(x/2) abs(x); 0 1 pi; 0 exp(1) ceil(x)]"
+    assert mcode(A) == expected
+    # row and columns
+    assert mcode(A[:,0]) == "[1; 0; 0]"
+    assert mcode(A[0,:]) == "[1 sin(x/2) abs(x)]"
+    # empty matrices
+    assert mcode(Matrix(0, 0, [])) == '[]'
+    assert mcode(Matrix(0, 3, [])) == 'zeros(0, 3)'
+    # annoying to read but correct
+    assert mcode(Matrix([[x, x - y, -y]])) == "[x x - y -y]"
+
+
+def test_vector_entries_hadamard():
+    # For a row or column, user might to use the other dimension
+    A = Matrix([[1, sin(2/x), 3*pi/x/5]])
+    assert mcode(A) == "[1 sin(2./x) 3*pi./(5*x)]"
+    assert mcode(A.T) == "[1; sin(2./x); 3*pi./(5*x)]"
+
+
+@XFAIL
+def test_Matrices_entries_not_hadamard():
+    # For Matrix with col >= 2, row >= 2, they need to be scalars
+    # FIXME: is it worth worrying about this?  Its not wrong, just
+    # leave it user's responsibility to put scalar data for x.
+    A = Matrix([[1, sin(2/x), 3*pi/x/5], [1, 2, x*y]])
+    expected = ("[1 sin(2/x) 3*pi/(5*x);\n"
+                "1        2        x*y]") # <- we give x.*y
+    assert mcode(A) == expected
+
+
+def test_MatrixSymbol():
+    n = Symbol('n', integer=True)
+    A = MatrixSymbol('A', n, n)
+    B = MatrixSymbol('B', n, n)
+    assert mcode(A*B) == "A*B"
+    assert mcode(B*A) == "B*A"
+    assert mcode(2*A*B) == "2*A*B"
+    assert mcode(B*2*A) == "2*B*A"
+    assert mcode(A*(B + 3*Identity(n))) == "A*(3*eye(n) + B)"
+    assert mcode(A**(x**2)) == "A^(x.^2)"
+    assert mcode(A**3) == "A^3"
+    assert mcode(A**S.Half) == "A^(1/2)"
+
+
+def test_MatrixSolve():
+    n = Symbol('n', integer=True)
+    A = MatrixSymbol('A', n, n)
+    x = MatrixSymbol('x', n, 1)
+    assert mcode(MatrixSolve(A, x)) == "A \\ x"
+
+def test_special_matrices():
+    assert mcode(6*Identity(3)) == "6*eye(3)"
+
+
+def test_containers():
+    assert mcode([1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]) == \
+        "{1, 2, 3, {4, 5, {6, 7}}, 8, {9, 10}, 11}"
+    assert mcode((1, 2, (3, 4))) == "{1, 2, {3, 4}}"
+    assert mcode([1]) == "{1}"
+    assert mcode((1,)) == "{1}"
+    assert mcode(Tuple(*[1, 2, 3])) == "{1, 2, 3}"
+    assert mcode((1, x*y, (3, x**2))) == "{1, x.*y, {3, x.^2}}"
+    # scalar, matrix, empty matrix and empty list
+    assert mcode((1, eye(3), Matrix(0, 0, []), [])) == "{1, [1 0 0; 0 1 0; 0 0 1], [], {}}"
+
+
+def test_octave_noninline():
+    source = mcode((x+y)/Catalan, assign_to='me', inline=False)
+    expected = (
+        "Catalan = %s;\n"
+        "me = (x + y)/Catalan;"
+    ) % Catalan.evalf(17)
+    assert source == expected
+
+
+def test_octave_piecewise():
+    expr = Piecewise((x, x < 1), (x**2, True))
+    assert mcode(expr) == "((x < 1).*(x) + (~(x < 1)).*(x.^2))"
+    assert mcode(expr, assign_to="r") == (
+        "r = ((x < 1).*(x) + (~(x < 1)).*(x.^2));")
+    assert mcode(expr, assign_to="r", inline=False) == (
+        "if (x < 1)\n"
+        "  r = x;\n"
+        "else\n"
+        "  r = x.^2;\n"
+        "end")
+    expr = Piecewise((x**2, x < 1), (x**3, x < 2), (x**4, x < 3), (x**5, True))
+    expected = ("((x < 1).*(x.^2) + (~(x < 1)).*( ...\n"
+                "(x < 2).*(x.^3) + (~(x < 2)).*( ...\n"
+                "(x < 3).*(x.^4) + (~(x < 3)).*(x.^5))))")
+    assert mcode(expr) == expected
+    assert mcode(expr, assign_to="r") == "r = " + expected + ";"
+    assert mcode(expr, assign_to="r", inline=False) == (
+        "if (x < 1)\n"
+        "  r = x.^2;\n"
+        "elseif (x < 2)\n"
+        "  r = x.^3;\n"
+        "elseif (x < 3)\n"
+        "  r = x.^4;\n"
+        "else\n"
+        "  r = x.^5;\n"
+        "end")
+    # Check that Piecewise without a True (default) condition error
+    expr = Piecewise((x, x < 1), (x**2, x > 1), (sin(x), x > 0))
+    raises(ValueError, lambda: mcode(expr))
+
+
+def test_octave_piecewise_times_const():
+    pw = Piecewise((x, x < 1), (x**2, True))
+    assert mcode(2*pw) == "2*((x < 1).*(x) + (~(x < 1)).*(x.^2))"
+    assert mcode(pw/x) == "((x < 1).*(x) + (~(x < 1)).*(x.^2))./x"
+    assert mcode(pw/(x*y)) == "((x < 1).*(x) + (~(x < 1)).*(x.^2))./(x.*y)"
+    assert mcode(pw/3) == "((x < 1).*(x) + (~(x < 1)).*(x.^2))/3"
+
+
+def test_octave_matrix_assign_to():
+    A = Matrix([[1, 2, 3]])
+    assert mcode(A, assign_to='a') == "a = [1 2 3];"
+    A = Matrix([[1, 2], [3, 4]])
+    assert mcode(A, assign_to='A') == "A = [1 2; 3 4];"
+
+
+def test_octave_matrix_assign_to_more():
+    # assigning to Symbol or MatrixSymbol requires lhs/rhs match
+    A = Matrix([[1, 2, 3]])
+    B = MatrixSymbol('B', 1, 3)
+    C = MatrixSymbol('C', 2, 3)
+    assert mcode(A, assign_to=B) == "B = [1 2 3];"
+    raises(ValueError, lambda: mcode(A, assign_to=x))
+    raises(ValueError, lambda: mcode(A, assign_to=C))
+
+
+def test_octave_matrix_1x1():
+    A = Matrix([[3]])
+    B = MatrixSymbol('B', 1, 1)
+    C = MatrixSymbol('C', 1, 2)
+    assert mcode(A, assign_to=B) == "B = 3;"
+    # FIXME?
+    #assert mcode(A, assign_to=x) == "x = 3;"
+    raises(ValueError, lambda: mcode(A, assign_to=C))
+
+
+def test_octave_matrix_elements():
+    A = Matrix([[x, 2, x*y]])
+    assert mcode(A[0, 0]**2 + A[0, 1] + A[0, 2]) == "x.^2 + x.*y + 2"
+    A = MatrixSymbol('AA', 1, 3)
+    assert mcode(A) == "AA"
+    assert mcode(A[0, 0]**2 + sin(A[0,1]) + A[0,2]) == \
+           "sin(AA(1, 2)) + AA(1, 1).^2 + AA(1, 3)"
+    assert mcode(sum(A)) == "AA(1, 1) + AA(1, 2) + AA(1, 3)"
+
+
+def test_octave_boolean():
+    assert mcode(True) == "true"
+    assert mcode(S.true) == "true"
+    assert mcode(False) == "false"
+    assert mcode(S.false) == "false"
+
+
+def test_octave_not_supported():
+    with raises(NotImplementedError):
+        mcode(S.ComplexInfinity)
+    f = Function('f')
+    assert mcode(f(x).diff(x), strict=False) == (
+        "% Not supported in Octave:\n"
+        "% Derivative\n"
+        "Derivative(f(x), x)"
+    )
+
+
+def test_octave_not_supported_not_on_whitelist():
+    from sympy.functions.special.polynomials import assoc_laguerre
+    with raises(NotImplementedError):
+        mcode(assoc_laguerre(x, y, z))
+
+
+def test_octave_expint():
+    assert mcode(expint(1, x)) == "expint(x)"
+    with raises(NotImplementedError):
+        mcode(expint(2, x))
+    assert mcode(expint(y, x), strict=False) == (
+        "% Not supported in Octave:\n"
+        "% expint\n"
+        "expint(y, x)"
+    )
+
+
+def test_trick_indent_with_end_else_words():
+    # words starting with "end" or "else" do not confuse the indenter
+    t1 = S('endless');
+    t2 = S('elsewhere');
+    pw = Piecewise((t1, x < 0), (t2, x <= 1), (1, True))
+    assert mcode(pw, inline=False) == (
+        "if (x < 0)\n"
+        "  endless\n"
+        "elseif (x <= 1)\n"
+        "  elsewhere\n"
+        "else\n"
+        "  1\n"
+        "end")
+
+
+def test_hadamard():
+    A = MatrixSymbol('A', 3, 3)
+    B = MatrixSymbol('B', 3, 3)
+    v = MatrixSymbol('v', 3, 1)
+    h = MatrixSymbol('h', 1, 3)
+    C = HadamardProduct(A, B)
+    n = Symbol('n')
+    assert mcode(C) == "A.*B"
+    assert mcode(C*v) == "(A.*B)*v"
+    assert mcode(h*C*v) == "h*(A.*B)*v"
+    assert mcode(C*A) == "(A.*B)*A"
+    # mixing Hadamard and scalar strange b/c we vectorize scalars
+    assert mcode(C*x*y) == "(x.*y)*(A.*B)"
+
+    # Testing HadamardPower:
+    assert mcode(HadamardPower(A, n)) == "A.**n"
+    assert mcode(HadamardPower(A, 1+n)) == "A.**(n + 1)"
+    assert mcode(HadamardPower(A*B.T, 1+n)) == "(A*B.T).**(n + 1)"
+
+
+def test_sparse():
+    M = SparseMatrix(5, 6, {})
+    M[2, 2] = 10;
+    M[1, 2] = 20;
+    M[1, 3] = 22;
+    M[0, 3] = 30;
+    M[3, 0] = x*y;
+    assert mcode(M) == (
+        "sparse([4 2 3 1 2], [1 3 3 4 4], [x.*y 20 10 30 22], 5, 6)"
+    )
+
+
+def test_sinc():
+    assert mcode(sinc(x)) == 'sinc(x/pi)'
+    assert mcode(sinc(x + 3)) == 'sinc((x + 3)/pi)'
+    assert mcode(sinc(pi*(x + 3))) == 'sinc(x + 3)'
+
+
+def test_trigfun():
+    for f in (sin, cos, tan, cot, sec, csc, asin, acos, acot, atan, asec, acsc,
+              sinh, cosh, tanh, coth, csch, sech, asinh, acosh, atanh, acoth,
+              asech, acsch):
+        assert octave_code(f(x) == f.__name__ + '(x)')
+
+
+def test_specfun():
+    n = Symbol('n')
+    for f in [besselj, bessely, besseli, besselk]:
+        assert octave_code(f(n, x)) == f.__name__ + '(n, x)'
+    for f in (erfc, erfi, erf, erfinv, erfcinv, fresnelc, fresnels, gamma):
+        assert octave_code(f(x)) == f.__name__ + '(x)'
+    assert octave_code(hankel1(n, x)) == 'besselh(n, 1, x)'
+    assert octave_code(hankel2(n, x)) == 'besselh(n, 2, x)'
+    assert octave_code(airyai(x)) == 'airy(0, x)'
+    assert octave_code(airyaiprime(x)) == 'airy(1, x)'
+    assert octave_code(airybi(x)) == 'airy(2, x)'
+    assert octave_code(airybiprime(x)) == 'airy(3, x)'
+    assert octave_code(uppergamma(n, x)) == '(gammainc(x, n, \'upper\').*gamma(n))'
+    assert octave_code(lowergamma(n, x)) == '(gammainc(x, n).*gamma(n))'
+    assert octave_code(z**lowergamma(n, x)) == 'z.^(gammainc(x, n).*gamma(n))'
+    assert octave_code(jn(n, x)) == 'sqrt(2)*sqrt(pi)*sqrt(1./x).*besselj(n + 1/2, x)/2'
+    assert octave_code(yn(n, x)) == 'sqrt(2)*sqrt(pi)*sqrt(1./x).*bessely(n + 1/2, x)/2'
+    assert octave_code(LambertW(x)) == 'lambertw(x)'
+    assert octave_code(LambertW(x, n)) == 'lambertw(n, x)'
+
+    # Automatic rewrite
+    assert octave_code(Ei(x)) == '(logint(exp(x)))'
+    assert octave_code(dirichlet_eta(x)) == '(((x == 1).*(log(2)) + (~(x == 1)).*((1 - 2.^(1 - x)).*zeta(x))))'
+    assert octave_code(riemann_xi(x)) == '(pi.^(-x/2).*x.*(x - 1).*gamma(x/2).*zeta(x)/2)'
+
+
+def test_MatrixElement_printing():
+    # test cases for issue #11821
+    A = MatrixSymbol("A", 1, 3)
+    B = MatrixSymbol("B", 1, 3)
+    C = MatrixSymbol("C", 1, 3)
+
+    assert mcode(A[0, 0]) == "A(1, 1)"
+    assert mcode(3 * A[0, 0]) == "3*A(1, 1)"
+
+    F = C[0, 0].subs(C, A - B)
+    assert mcode(F) == "(A - B)(1, 1)"
+
+
+def test_zeta_printing_issue_14820():
+    assert octave_code(zeta(x)) == 'zeta(x)'
+    with raises(NotImplementedError):
+        octave_code(zeta(x, y))
+
+
+def test_automatic_rewrite():
+    assert octave_code(Li(x)) == '(logint(x) - logint(2))'
+    assert octave_code(erf2(x, y)) == '(-erf(x) + erf(y))'

lib/python3.12/site-packages/sympy/printing/tests/test_preview.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+from sympy.core.relational import Eq
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.printing.preview import preview
+
+from io import BytesIO
+
+
+def test_preview():
+    x = Symbol('x')
+    obj = BytesIO()
+    try:
+        preview(x, output='png', viewer='BytesIO', outputbuffer=obj)
+    except RuntimeError:
+        pass  # latex not installed on CI server
+
+
+def test_preview_unicode_symbol():
+    # issue 9107
+    a = Symbol('α')
+    obj = BytesIO()
+    try:
+        preview(a, output='png', viewer='BytesIO', outputbuffer=obj)
+    except RuntimeError:
+        pass  # latex not installed on CI server
+
+
+def test_preview_latex_construct_in_expr():
+    # see PR 9801
+    x = Symbol('x')
+    pw = Piecewise((1, Eq(x, 0)), (0, True))
+    obj = BytesIO()
+    try:
+        preview(pw, output='png', viewer='BytesIO', outputbuffer=obj)
+    except RuntimeError:
+        pass  # latex not installed on CI server

lib/python3.12/site-packages/sympy/printing/tests/test_pycode.py

@@ -0,0 +1,429 @@
+from sympy.codegen import Assignment
+from sympy.codegen.ast import none
+from sympy.codegen.cfunctions import expm1, log1p
+from sympy.codegen.scipy_nodes import cosm1
+from sympy.codegen.matrix_nodes import MatrixSolve
+from sympy.core import Expr, Mod, symbols, Eq, Le, Gt, zoo, oo, Rational, Pow
+from sympy.core.numbers import pi
+from sympy.core.singleton import S
+from sympy.functions import acos, KroneckerDelta, Piecewise, sign, sqrt, Min, Max, cot, acsch, asec, coth, sec
+from sympy.logic import And, Or
+from sympy.matrices import SparseMatrix, MatrixSymbol, Identity
+from sympy.printing.pycode import (
+    MpmathPrinter, PythonCodePrinter, pycode, SymPyPrinter
+)
+from sympy.printing.tensorflow import TensorflowPrinter
+from sympy.printing.numpy import NumPyPrinter, SciPyPrinter
+from sympy.testing.pytest import raises, skip
+from sympy.tensor import IndexedBase, Idx
+from sympy.tensor.array.expressions.array_expressions import ArraySymbol, ArrayDiagonal, ArrayContraction, ZeroArray, OneArray
+from sympy.external import import_module
+from sympy.functions.special.gamma_functions import loggamma
+
+
+x, y, z = symbols('x y z')
+p = IndexedBase("p")
+
+
+def test_PythonCodePrinter():
+    prntr = PythonCodePrinter()
+
+    assert not prntr.module_imports
+
+    assert prntr.doprint(x**y) == 'x**y'
+    assert prntr.doprint(Mod(x, 2)) == 'x % 2'
+    assert prntr.doprint(-Mod(x, y)) == '-(x % y)'
+    assert prntr.doprint(Mod(-x, y)) == '(-x) % y'
+    assert prntr.doprint(And(x, y)) == 'x and y'
+    assert prntr.doprint(Or(x, y)) == 'x or y'
+    assert prntr.doprint(1/(x+y)) == '1/(x + y)'
+    assert not prntr.module_imports
+
+    assert prntr.doprint(pi) == 'math.pi'
+    assert prntr.module_imports == {'math': {'pi'}}
+
+    assert prntr.doprint(x**Rational(1, 2)) == 'math.sqrt(x)'
+    assert prntr.doprint(sqrt(x)) == 'math.sqrt(x)'
+    assert prntr.module_imports == {'math': {'pi', 'sqrt'}}
+
+    assert prntr.doprint(acos(x)) == 'math.acos(x)'
+    assert prntr.doprint(cot(x)) == '(1/math.tan(x))'
+    assert prntr.doprint(coth(x)) == '((math.exp(x) + math.exp(-x))/(math.exp(x) - math.exp(-x)))'
+    assert prntr.doprint(asec(x)) == '(math.acos(1/x))'
+    assert prntr.doprint(acsch(x)) == '(math.log(math.sqrt(1 + x**(-2)) + 1/x))'
+
+    assert prntr.doprint(Assignment(x, 2)) == 'x = 2'
+    assert prntr.doprint(Piecewise((1, Eq(x, 0)),
+                        (2, x>6))) == '((1) if (x == 0) else (2) if (x > 6) else None)'
+    assert prntr.doprint(Piecewise((2, Le(x, 0)),
+                        (3, Gt(x, 0)), evaluate=False)) == '((2) if (x <= 0) else'\
+                                                        ' (3) if (x > 0) else None)'
+    assert prntr.doprint(sign(x)) == '(0.0 if x == 0 else math.copysign(1, x))'
+    assert prntr.doprint(p[0, 1]) == 'p[0, 1]'
+    assert prntr.doprint(KroneckerDelta(x,y)) == '(1 if x == y else 0)'
+
+    assert prntr.doprint((2,3)) == "(2, 3)"
+    assert prntr.doprint([2,3]) == "[2, 3]"
+
+    assert prntr.doprint(Min(x, y)) == "min(x, y)"
+    assert prntr.doprint(Max(x, y)) == "max(x, y)"
+
+
+def test_PythonCodePrinter_standard():
+    prntr = PythonCodePrinter()
+
+    assert prntr.standard == 'python3'
+
+    raises(ValueError, lambda: PythonCodePrinter({'standard':'python4'}))
+
+
+def test_MpmathPrinter():
+    p = MpmathPrinter()
+    assert p.doprint(sign(x)) == 'mpmath.sign(x)'
+    assert p.doprint(Rational(1, 2)) == 'mpmath.mpf(1)/mpmath.mpf(2)'
+
+    assert p.doprint(S.Exp1) == 'mpmath.e'
+    assert p.doprint(S.Pi) == 'mpmath.pi'
+    assert p.doprint(S.GoldenRatio) == 'mpmath.phi'
+    assert p.doprint(S.EulerGamma) == 'mpmath.euler'
+    assert p.doprint(S.NaN) == 'mpmath.nan'
+    assert p.doprint(S.Infinity) == 'mpmath.inf'
+    assert p.doprint(S.NegativeInfinity) == 'mpmath.ninf'
+    assert p.doprint(loggamma(x)) == 'mpmath.loggamma(x)'
+
+
+def test_NumPyPrinter():
+    from sympy.core.function import Lambda
+    from sympy.matrices.expressions.adjoint import Adjoint
+    from sympy.matrices.expressions.diagonal import (DiagMatrix, DiagonalMatrix, DiagonalOf)
+    from sympy.matrices.expressions.funcmatrix import FunctionMatrix
+    from sympy.matrices.expressions.hadamard import HadamardProduct
+    from sympy.matrices.expressions.kronecker import KroneckerProduct
+    from sympy.matrices.expressions.special import (OneMatrix, ZeroMatrix)
+    from sympy.abc import a, b
+    p = NumPyPrinter()
+    assert p.doprint(sign(x)) == 'numpy.sign(x)'
+    A = MatrixSymbol("A", 2, 2)
+    B = MatrixSymbol("B", 2, 2)
+    C = MatrixSymbol("C", 1, 5)
+    D = MatrixSymbol("D", 3, 4)
+    assert p.doprint(A**(-1)) == "numpy.linalg.inv(A)"
+    assert p.doprint(A**5) == "numpy.linalg.matrix_power(A, 5)"
+    assert p.doprint(Identity(3)) == "numpy.eye(3)"
+
+    u = MatrixSymbol('x', 2, 1)
+    v = MatrixSymbol('y', 2, 1)
+    assert p.doprint(MatrixSolve(A, u)) == 'numpy.linalg.solve(A, x)'
+    assert p.doprint(MatrixSolve(A, u) + v) == 'numpy.linalg.solve(A, x) + y'
+
+    assert p.doprint(ZeroMatrix(2, 3)) == "numpy.zeros((2, 3))"
+    assert p.doprint(OneMatrix(2, 3)) == "numpy.ones((2, 3))"
+    assert p.doprint(FunctionMatrix(4, 5, Lambda((a, b), a + b))) == \
+        "numpy.fromfunction(lambda a, b: a + b, (4, 5))"
+    assert p.doprint(HadamardProduct(A, B)) == "numpy.multiply(A, B)"
+    assert p.doprint(KroneckerProduct(A, B)) == "numpy.kron(A, B)"
+    assert p.doprint(Adjoint(A)) == "numpy.conjugate(numpy.transpose(A))"
+    assert p.doprint(DiagonalOf(A)) == "numpy.reshape(numpy.diag(A), (-1, 1))"
+    assert p.doprint(DiagMatrix(C)) == "numpy.diagflat(C)"
+    assert p.doprint(DiagonalMatrix(D)) == "numpy.multiply(D, numpy.eye(3, 4))"
+
+    # Workaround for numpy negative integer power errors
+    assert p.doprint(x**-1) == 'x**(-1.0)'
+    assert p.doprint(x**-2) == 'x**(-2.0)'
+
+    expr = Pow(2, -1, evaluate=False)
+    assert p.doprint(expr) == "2**(-1.0)"
+
+    assert p.doprint(S.Exp1) == 'numpy.e'
+    assert p.doprint(S.Pi) == 'numpy.pi'
+    assert p.doprint(S.EulerGamma) == 'numpy.euler_gamma'
+    assert p.doprint(S.NaN) == 'numpy.nan'
+    assert p.doprint(S.Infinity) == 'numpy.inf'
+    assert p.doprint(S.NegativeInfinity) == '-numpy.inf'
+
+    # Function rewriting operator precedence fix
+    assert p.doprint(sec(x)**2) == '(numpy.cos(x)**(-1.0))**2'
+
+
+def test_issue_18770():
+    numpy = import_module('numpy')
+    if not numpy:
+        skip("numpy not installed.")
+
+    from sympy.functions.elementary.miscellaneous import (Max, Min)
+    from sympy.utilities.lambdify import lambdify
+
+    expr1 = Min(0.1*x + 3, x + 1, 0.5*x + 1)
+    func = lambdify(x, expr1, "numpy")
+    assert (func(numpy.linspace(0, 3, 3)) == [1.0, 1.75, 2.5 ]).all()
+    assert  func(4) == 3
+
+    expr1 = Max(x**2, x**3)
+    func = lambdify(x,expr1, "numpy")
+    assert (func(numpy.linspace(-1, 2, 4)) == [1, 0, 1, 8] ).all()
+    assert func(4) == 64
+
+
+def test_SciPyPrinter():
+    p = SciPyPrinter()
+    expr = acos(x)
+    assert 'numpy' not in p.module_imports
+    assert p.doprint(expr) == 'numpy.arccos(x)'
+    assert 'numpy' in p.module_imports
+    assert not any(m.startswith('scipy') for m in p.module_imports)
+    smat = SparseMatrix(2, 5, {(0, 1): 3})
+    assert p.doprint(smat) == \
+        'scipy.sparse.coo_matrix(([3], ([0], [1])), shape=(2, 5))'
+    assert 'scipy.sparse' in p.module_imports
+
+    assert p.doprint(S.GoldenRatio) == 'scipy.constants.golden_ratio'
+    assert p.doprint(S.Pi) == 'scipy.constants.pi'
+    assert p.doprint(S.Exp1) == 'numpy.e'
+
+
+def test_pycode_reserved_words():
+    s1, s2 = symbols('if else')
+    raises(ValueError, lambda: pycode(s1 + s2, error_on_reserved=True))
+    py_str = pycode(s1 + s2)
+    assert py_str in ('else_ + if_', 'if_ + else_')
+
+
+def test_issue_20762():
+    # Make sure pycode removes curly braces from subscripted variables
+    a_b, b, a_11 = symbols('a_{b} b a_{11}')
+    expr = a_b*b
+    assert pycode(expr) == 'a_b*b'
+    expr = a_11*b
+    assert pycode(expr) == 'a_11*b'
+
+
+def test_sqrt():
+    prntr = PythonCodePrinter()
+    assert prntr._print_Pow(sqrt(x), rational=False) == 'math.sqrt(x)'
+    assert prntr._print_Pow(1/sqrt(x), rational=False) == '1/math.sqrt(x)'
+
+    prntr = PythonCodePrinter({'standard' : 'python3'})
+    assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1/2)'
+    assert prntr._print_Pow(1/sqrt(x), rational=True) == 'x**(-1/2)'
+
+    prntr = MpmathPrinter()
+    assert prntr._print_Pow(sqrt(x), rational=False) == 'mpmath.sqrt(x)'
+    assert prntr._print_Pow(sqrt(x), rational=True) == \
+        "x**(mpmath.mpf(1)/mpmath.mpf(2))"
+
+    prntr = NumPyPrinter()
+    assert prntr._print_Pow(sqrt(x), rational=False) == 'numpy.sqrt(x)'
+    assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1/2)'
+
+    prntr = SciPyPrinter()
+    assert prntr._print_Pow(sqrt(x), rational=False) == 'numpy.sqrt(x)'
+    assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1/2)'
+
+    prntr = SymPyPrinter()
+    assert prntr._print_Pow(sqrt(x), rational=False) == 'sympy.sqrt(x)'
+    assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1/2)'
+
+
+def test_frac():
+    from sympy.functions.elementary.integers import frac
+
+    expr = frac(x)
+    prntr = NumPyPrinter()
+    assert prntr.doprint(expr) == 'numpy.mod(x, 1)'
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expr) == 'numpy.mod(x, 1)'
+
+    prntr = PythonCodePrinter()
+    assert prntr.doprint(expr) == 'x % 1'
+
+    prntr = MpmathPrinter()
+    assert prntr.doprint(expr) == 'mpmath.frac(x)'
+
+    prntr = SymPyPrinter()
+    assert prntr.doprint(expr) == 'sympy.functions.elementary.integers.frac(x)'
+
+
+class CustomPrintedObject(Expr):
+    def _numpycode(self, printer):
+        return 'numpy'
+
+    def _mpmathcode(self, printer):
+        return 'mpmath'
+
+
+def test_printmethod():
+    obj = CustomPrintedObject()
+    assert NumPyPrinter().doprint(obj) == 'numpy'
+    assert MpmathPrinter().doprint(obj) == 'mpmath'
+
+
+def test_codegen_ast_nodes():
+    assert pycode(none) == 'None'
+
+
+def test_issue_14283():
+    prntr = PythonCodePrinter()
+
+    assert prntr.doprint(zoo) == "math.nan"
+    assert prntr.doprint(-oo) == "float('-inf')"
+
+
+def test_NumPyPrinter_print_seq():
+    n = NumPyPrinter()
+
+    assert n._print_seq(range(2)) == '(0, 1,)'
+
+
+def test_issue_16535_16536():
+    from sympy.functions.special.gamma_functions import (lowergamma, uppergamma)
+
+    a = symbols('a')
+    expr1 = lowergamma(a, x)
+    expr2 = uppergamma(a, x)
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expr1) == 'scipy.special.gamma(a)*scipy.special.gammainc(a, x)'
+    assert prntr.doprint(expr2) == 'scipy.special.gamma(a)*scipy.special.gammaincc(a, x)'
+
+    p_numpy = NumPyPrinter()
+    p_pycode = PythonCodePrinter({'strict': False})
+
+    for expr in [expr1, expr2]:
+        with raises(NotImplementedError):
+            p_numpy.doprint(expr1)
+        assert "Not supported" in p_pycode.doprint(expr)
+
+
+def test_Integral():
+    from sympy.functions.elementary.exponential import exp
+    from sympy.integrals.integrals import Integral
+
+    single = Integral(exp(-x), (x, 0, oo))
+    double = Integral(x**2*exp(x*y), (x, -z, z), (y, 0, z))
+    indefinite = Integral(x**2, x)
+    evaluateat = Integral(x**2, (x, 1))
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(single) == 'scipy.integrate.quad(lambda x: numpy.exp(-x), 0, numpy.inf)[0]'
+    assert prntr.doprint(double) == 'scipy.integrate.nquad(lambda x, y: x**2*numpy.exp(x*y), ((-z, z), (0, z)))[0]'
+    raises(NotImplementedError, lambda: prntr.doprint(indefinite))
+    raises(NotImplementedError, lambda: prntr.doprint(evaluateat))
+
+    prntr = MpmathPrinter()
+    assert prntr.doprint(single) == 'mpmath.quad(lambda x: mpmath.exp(-x), (0, mpmath.inf))'
+    assert prntr.doprint(double) == 'mpmath.quad(lambda x, y: x**2*mpmath.exp(x*y), (-z, z), (0, z))'
+    raises(NotImplementedError, lambda: prntr.doprint(indefinite))
+    raises(NotImplementedError, lambda: prntr.doprint(evaluateat))
+
+
+def test_fresnel_integrals():
+    from sympy.functions.special.error_functions import (fresnelc, fresnels)
+
+    expr1 = fresnelc(x)
+    expr2 = fresnels(x)
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expr1) == 'scipy.special.fresnel(x)[1]'
+    assert prntr.doprint(expr2) == 'scipy.special.fresnel(x)[0]'
+
+    p_numpy = NumPyPrinter()
+    p_pycode = PythonCodePrinter()
+    p_mpmath = MpmathPrinter()
+    for expr in [expr1, expr2]:
+        with raises(NotImplementedError):
+            p_numpy.doprint(expr)
+        with raises(NotImplementedError):
+            p_pycode.doprint(expr)
+
+    assert p_mpmath.doprint(expr1) == 'mpmath.fresnelc(x)'
+    assert p_mpmath.doprint(expr2) == 'mpmath.fresnels(x)'
+
+
+def test_beta():
+    from sympy.functions.special.beta_functions import beta
+
+    expr = beta(x, y)
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expr) == 'scipy.special.beta(x, y)'
+
+    prntr = NumPyPrinter()
+    assert prntr.doprint(expr) == '(math.gamma(x)*math.gamma(y)/math.gamma(x + y))'
+
+    prntr = PythonCodePrinter()
+    assert prntr.doprint(expr) == '(math.gamma(x)*math.gamma(y)/math.gamma(x + y))'
+
+    prntr = PythonCodePrinter({'allow_unknown_functions': True})
+    assert prntr.doprint(expr) == '(math.gamma(x)*math.gamma(y)/math.gamma(x + y))'
+
+    prntr = MpmathPrinter()
+    assert prntr.doprint(expr) ==  'mpmath.beta(x, y)'
+
+def test_airy():
+    from sympy.functions.special.bessel import (airyai, airybi)
+
+    expr1 = airyai(x)
+    expr2 = airybi(x)
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expr1) == 'scipy.special.airy(x)[0]'
+    assert prntr.doprint(expr2) == 'scipy.special.airy(x)[2]'
+
+    prntr = NumPyPrinter({'strict': False})
+    assert "Not supported" in prntr.doprint(expr1)
+    assert "Not supported" in prntr.doprint(expr2)
+
+    prntr = PythonCodePrinter({'strict': False})
+    assert "Not supported" in prntr.doprint(expr1)
+    assert "Not supported" in prntr.doprint(expr2)
+
+def test_airy_prime():
+    from sympy.functions.special.bessel import (airyaiprime, airybiprime)
+
+    expr1 = airyaiprime(x)
+    expr2 = airybiprime(x)
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expr1) == 'scipy.special.airy(x)[1]'
+    assert prntr.doprint(expr2) == 'scipy.special.airy(x)[3]'
+
+    prntr = NumPyPrinter({'strict': False})
+    assert "Not supported" in prntr.doprint(expr1)
+    assert "Not supported" in prntr.doprint(expr2)
+
+    prntr = PythonCodePrinter({'strict': False})
+    assert "Not supported" in prntr.doprint(expr1)
+    assert "Not supported" in prntr.doprint(expr2)
+
+
+def test_numerical_accuracy_functions():
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expm1(x)) == 'numpy.expm1(x)'
+    assert prntr.doprint(log1p(x)) == 'numpy.log1p(x)'
+    assert prntr.doprint(cosm1(x)) == 'scipy.special.cosm1(x)'
+
+def test_array_printer():
+    A = ArraySymbol('A', (4,4,6,6,6))
+    I = IndexedBase('I')
+    i,j,k = Idx('i', (0,1)), Idx('j', (2,3)), Idx('k', (4,5))
+
+    prntr = NumPyPrinter()
+    assert prntr.doprint(ZeroArray(5)) == 'numpy.zeros((5,))'
+    assert prntr.doprint(OneArray(5)) == 'numpy.ones((5,))'
+    assert prntr.doprint(ArrayContraction(A, [2,3])) == 'numpy.einsum("abccd->abd", A)'
+    assert prntr.doprint(I) == 'I'
+    assert prntr.doprint(ArrayDiagonal(A, [2,3,4])) == 'numpy.einsum("abccc->abc", A)'
+    assert prntr.doprint(ArrayDiagonal(A, [0,1], [2,3])) == 'numpy.einsum("aabbc->cab", A)'
+    assert prntr.doprint(ArrayContraction(A, [2], [3])) == 'numpy.einsum("abcde->abe", A)'
+    assert prntr.doprint(Assignment(I[i,j,k], I[i,j,k])) == 'I = I'
+
+    prntr = TensorflowPrinter()
+    assert prntr.doprint(ZeroArray(5)) == 'tensorflow.zeros((5,))'
+    assert prntr.doprint(OneArray(5)) == 'tensorflow.ones((5,))'
+    assert prntr.doprint(ArrayContraction(A, [2,3])) == 'tensorflow.linalg.einsum("abccd->abd", A)'
+    assert prntr.doprint(I) == 'I'
+    assert prntr.doprint(ArrayDiagonal(A, [2,3,4])) == 'tensorflow.linalg.einsum("abccc->abc", A)'
+    assert prntr.doprint(ArrayDiagonal(A, [0,1], [2,3])) == 'tensorflow.linalg.einsum("aabbc->cab", A)'
+    assert prntr.doprint(ArrayContraction(A, [2], [3])) == 'tensorflow.linalg.einsum("abcde->abe", A)'
+    assert prntr.doprint(Assignment(I[i,j,k], I[i,j,k])) == 'I = I'

lib/python3.12/site-packages/sympy/printing/tests/test_repr.py

@@ -0,0 +1,382 @@
+from __future__ import annotations
+from typing import Any
+
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+from sympy.assumptions.ask import Q
+from sympy.core.function import (Function, WildFunction)
+from sympy.core.numbers import (AlgebraicNumber, Float, Integer, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, Wild, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import sin
+from sympy.functions.special.delta_functions import Heaviside
+from sympy.logic.boolalg import (false, true)
+from sympy.matrices.dense import (Matrix, ones)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.immutable import ImmutableDenseMatrix
+from sympy.combinatorics import Cycle, Permutation
+from sympy.core.symbol import Str
+from sympy.geometry import Point, Ellipse
+from sympy.printing import srepr
+from sympy.polys import ring, field, ZZ, QQ, lex, grlex, Poly
+from sympy.polys.polyclasses import DMP
+from sympy.polys.agca.extensions import FiniteExtension
+
+x, y = symbols('x,y')
+
+# eval(srepr(expr)) == expr has to succeed in the right environment. The right
+# environment is the scope of "from sympy import *" for most cases.
+ENV: dict[str, Any] = {"Str": Str}
+exec("from sympy import *", ENV)
+
+
+def sT(expr, string, import_stmt=None, **kwargs):
+    """
+    sT := sreprTest
+
+    Tests that srepr delivers the expected string and that
+    the condition eval(srepr(expr))==expr holds.
+    """
+    if import_stmt is None:
+        ENV2 = ENV
+    else:
+        ENV2 = ENV.copy()
+        exec(import_stmt, ENV2)
+
+    assert srepr(expr, **kwargs) == string
+    assert eval(string, ENV2) == expr
+
+
+def test_printmethod():
+    class R(Abs):
+        def _sympyrepr(self, printer):
+            return "foo(%s)" % printer._print(self.args[0])
+    assert srepr(R(x)) == "foo(Symbol('x'))"
+
+
+def test_Add():
+    sT(x + y, "Add(Symbol('x'), Symbol('y'))")
+    assert srepr(x**2 + 1, order='lex') == "Add(Pow(Symbol('x'), Integer(2)), Integer(1))"
+    assert srepr(x**2 + 1, order='old') == "Add(Integer(1), Pow(Symbol('x'), Integer(2)))"
+    assert srepr(sympify('x + 3 - 2', evaluate=False), order='none') == "Add(Symbol('x'), Integer(3), Mul(Integer(-1), Integer(2)))"
+
+
+def test_more_than_255_args_issue_10259():
+    from sympy.core.add import Add
+    from sympy.core.mul import Mul
+    for op in (Add, Mul):
+        expr = op(*symbols('x:256'))
+        assert eval(srepr(expr)) == expr
+
+
+def test_Function():
+    sT(Function("f")(x), "Function('f')(Symbol('x'))")
+    # test unapplied Function
+    sT(Function('f'), "Function('f')")
+
+    sT(sin(x), "sin(Symbol('x'))")
+    sT(sin, "sin")
+
+
+def test_Heaviside():
+    sT(Heaviside(x), "Heaviside(Symbol('x'))")
+    sT(Heaviside(x, 1), "Heaviside(Symbol('x'), Integer(1))")
+
+
+def test_Geometry():
+    sT(Point(0, 0), "Point2D(Integer(0), Integer(0))")
+    sT(Ellipse(Point(0, 0), 5, 1),
+       "Ellipse(Point2D(Integer(0), Integer(0)), Integer(5), Integer(1))")
+    # TODO more tests
+
+
+def test_Singletons():
+    sT(S.Catalan, 'Catalan')
+    sT(S.ComplexInfinity, 'zoo')
+    sT(S.EulerGamma, 'EulerGamma')
+    sT(S.Exp1, 'E')
+    sT(S.GoldenRatio, 'GoldenRatio')
+    sT(S.TribonacciConstant, 'TribonacciConstant')
+    sT(S.Half, 'Rational(1, 2)')
+    sT(S.ImaginaryUnit, 'I')
+    sT(S.Infinity, 'oo')
+    sT(S.NaN, 'nan')
+    sT(S.NegativeInfinity, '-oo')
+    sT(S.NegativeOne, 'Integer(-1)')
+    sT(S.One, 'Integer(1)')
+    sT(S.Pi, 'pi')
+    sT(S.Zero, 'Integer(0)')
+    sT(S.Complexes, 'Complexes')
+    sT(S.EmptySequence, 'EmptySequence')
+    sT(S.EmptySet, 'EmptySet')
+    # sT(S.IdentityFunction, 'Lambda(_x, _x)')
+    sT(S.Naturals, 'Naturals')
+    sT(S.Naturals0, 'Naturals0')
+    sT(S.Rationals, 'Rationals')
+    sT(S.Reals, 'Reals')
+    sT(S.UniversalSet, 'UniversalSet')
+
+
+def test_Integer():
+    sT(Integer(4), "Integer(4)")
+
+
+def test_list():
+    sT([x, Integer(4)], "[Symbol('x'), Integer(4)]")
+
+
+def test_Matrix():
+    for cls, name in [(Matrix, "MutableDenseMatrix"), (ImmutableDenseMatrix, "ImmutableDenseMatrix")]:
+        sT(cls([[x**+1, 1], [y, x + y]]),
+           "%s([[Symbol('x'), Integer(1)], [Symbol('y'), Add(Symbol('x'), Symbol('y'))]])" % name)
+
+        sT(cls(), "%s([])" % name)
+
+        sT(cls([[x**+1, 1], [y, x + y]]), "%s([[Symbol('x'), Integer(1)], [Symbol('y'), Add(Symbol('x'), Symbol('y'))]])" % name)
+
+
+def test_empty_Matrix():
+    sT(ones(0, 3), "MutableDenseMatrix(0, 3, [])")
+    sT(ones(4, 0), "MutableDenseMatrix(4, 0, [])")
+    sT(ones(0, 0), "MutableDenseMatrix([])")
+
+
+def test_Rational():
+    sT(Rational(1, 3), "Rational(1, 3)")
+    sT(Rational(-1, 3), "Rational(-1, 3)")
+
+
+def test_Float():
+    sT(Float('1.23', dps=3), "Float('1.22998', precision=13)")
+    sT(Float('1.23456789', dps=9), "Float('1.23456788994', precision=33)")
+    sT(Float('1.234567890123456789', dps=19),
+       "Float('1.234567890123456789013', precision=66)")
+    sT(Float('0.60038617995049726', dps=15),
+       "Float('0.60038617995049726', precision=53)")
+
+    sT(Float('1.23', precision=13), "Float('1.22998', precision=13)")
+    sT(Float('1.23456789', precision=33),
+       "Float('1.23456788994', precision=33)")
+    sT(Float('1.234567890123456789', precision=66),
+       "Float('1.234567890123456789013', precision=66)")
+    sT(Float('0.60038617995049726', precision=53),
+       "Float('0.60038617995049726', precision=53)")
+
+    sT(Float('0.60038617995049726', 15),
+       "Float('0.60038617995049726', precision=53)")
+
+
+def test_Symbol():
+    sT(x, "Symbol('x')")
+    sT(y, "Symbol('y')")
+    sT(Symbol('x', negative=True), "Symbol('x', negative=True)")
+
+
+def test_Symbol_two_assumptions():
+    x = Symbol('x', negative=0, integer=1)
+    # order could vary
+    s1 = "Symbol('x', integer=True, negative=False)"
+    s2 = "Symbol('x', negative=False, integer=True)"
+    assert srepr(x) in (s1, s2)
+    assert eval(srepr(x), ENV) == x
+
+
+def test_Symbol_no_special_commutative_treatment():
+    sT(Symbol('x'), "Symbol('x')")
+    sT(Symbol('x', commutative=False), "Symbol('x', commutative=False)")
+    sT(Symbol('x', commutative=0), "Symbol('x', commutative=False)")
+    sT(Symbol('x', commutative=True), "Symbol('x', commutative=True)")
+    sT(Symbol('x', commutative=1), "Symbol('x', commutative=True)")
+
+
+def test_Wild():
+    sT(Wild('x', even=True), "Wild('x', even=True)")
+
+
+def test_Dummy():
+    d = Dummy('d')
+    sT(d, "Dummy('d', dummy_index=%s)" % str(d.dummy_index))
+
+
+def test_Dummy_assumption():
+    d = Dummy('d', nonzero=True)
+    assert d == eval(srepr(d))
+    s1 = "Dummy('d', dummy_index=%s, nonzero=True)" % str(d.dummy_index)
+    s2 = "Dummy('d', nonzero=True, dummy_index=%s)" % str(d.dummy_index)
+    assert srepr(d) in (s1, s2)
+
+
+def test_Dummy_from_Symbol():
+    # should not get the full dictionary of assumptions
+    n = Symbol('n', integer=True)
+    d = n.as_dummy()
+    assert srepr(d
+        ) == "Dummy('n', dummy_index=%s)" % str(d.dummy_index)
+
+
+def test_tuple():
+    sT((x,), "(Symbol('x'),)")
+    sT((x, y), "(Symbol('x'), Symbol('y'))")
+
+
+def test_WildFunction():
+    sT(WildFunction('w'), "WildFunction('w')")
+
+
+def test_settins():
+    raises(TypeError, lambda: srepr(x, method="garbage"))
+
+
+def test_Mul():
+    sT(3*x**3*y, "Mul(Integer(3), Pow(Symbol('x'), Integer(3)), Symbol('y'))")
+    assert srepr(3*x**3*y, order='old') == "Mul(Integer(3), Symbol('y'), Pow(Symbol('x'), Integer(3)))"
+    assert srepr(sympify('(x+4)*2*x*7', evaluate=False), order='none') == "Mul(Add(Symbol('x'), Integer(4)), Integer(2), Symbol('x'), Integer(7))"
+
+
+def test_AlgebraicNumber():
+    a = AlgebraicNumber(sqrt(2))
+    sT(a, "AlgebraicNumber(Pow(Integer(2), Rational(1, 2)), [Integer(1), Integer(0)])")
+    a = AlgebraicNumber(root(-2, 3))
+    sT(a, "AlgebraicNumber(Pow(Integer(-2), Rational(1, 3)), [Integer(1), Integer(0)])")
+
+
+def test_PolyRing():
+    assert srepr(ring("x", ZZ, lex)[0]) == "PolyRing((Symbol('x'),), ZZ, lex)"
+    assert srepr(ring("x,y", QQ, grlex)[0]) == "PolyRing((Symbol('x'), Symbol('y')), QQ, grlex)"
+    assert srepr(ring("x,y,z", ZZ["t"], lex)[0]) == "PolyRing((Symbol('x'), Symbol('y'), Symbol('z')), ZZ[t], lex)"
+
+
+def test_FracField():
+    assert srepr(field("x", ZZ, lex)[0]) == "FracField((Symbol('x'),), ZZ, lex)"
+    assert srepr(field("x,y", QQ, grlex)[0]) == "FracField((Symbol('x'), Symbol('y')), QQ, grlex)"
+    assert srepr(field("x,y,z", ZZ["t"], lex)[0]) == "FracField((Symbol('x'), Symbol('y'), Symbol('z')), ZZ[t], lex)"
+
+
+def test_PolyElement():
+    R, x, y = ring("x,y", ZZ)
+    assert srepr(3*x**2*y + 1) == "PolyElement(PolyRing((Symbol('x'), Symbol('y')), ZZ, lex), [((2, 1), 3), ((0, 0), 1)])"
+
+
+def test_FracElement():
+    F, x, y = field("x,y", ZZ)
+    assert srepr((3*x**2*y + 1)/(x - y**2)) == "FracElement(FracField((Symbol('x'), Symbol('y')), ZZ, lex), [((2, 1), 3), ((0, 0), 1)], [((1, 0), 1), ((0, 2), -1)])"
+
+
+def test_FractionField():
+    assert srepr(QQ.frac_field(x)) == \
+        "FractionField(FracField((Symbol('x'),), QQ, lex))"
+    assert srepr(QQ.frac_field(x, y, order=grlex)) == \
+        "FractionField(FracField((Symbol('x'), Symbol('y')), QQ, grlex))"
+
+
+def test_PolynomialRingBase():
+    assert srepr(ZZ.old_poly_ring(x)) == \
+        "GlobalPolynomialRing(ZZ, Symbol('x'))"
+    assert srepr(ZZ[x].old_poly_ring(y)) == \
+        "GlobalPolynomialRing(ZZ[x], Symbol('y'))"
+    assert srepr(QQ.frac_field(x).old_poly_ring(y)) == \
+        "GlobalPolynomialRing(FractionField(FracField((Symbol('x'),), QQ, lex)), Symbol('y'))"
+
+
+def test_DMP():
+    p1 = DMP([1, 2], ZZ)
+    p2 = ZZ.old_poly_ring(x)([1, 2])
+    if GROUND_TYPES != 'flint':
+        assert srepr(p1) == "DMP_Python([1, 2], ZZ)"
+        assert srepr(p2) == "DMP_Python([1, 2], ZZ)"
+    else:
+        assert srepr(p1) == "DUP_Flint([1, 2], ZZ)"
+        assert srepr(p2) == "DUP_Flint([1, 2], ZZ)"
+
+
+def test_FiniteExtension():
+    assert srepr(FiniteExtension(Poly(x**2 + 1, x))) == \
+        "FiniteExtension(Poly(x**2 + 1, x, domain='ZZ'))"
+
+
+def test_ExtensionElement():
+    A = FiniteExtension(Poly(x**2 + 1, x))
+    if GROUND_TYPES != 'flint':
+        ans = "ExtElem(DMP_Python([1, 0], ZZ), FiniteExtension(Poly(x**2 + 1, x, domain='ZZ')))"
+    else:
+        ans = "ExtElem(DUP_Flint([1, 0], ZZ), FiniteExtension(Poly(x**2 + 1, x, domain='ZZ')))"
+    assert srepr(A.generator) == ans
+
+def test_BooleanAtom():
+    assert srepr(true) == "true"
+    assert srepr(false) == "false"
+
+
+def test_Integers():
+    sT(S.Integers, "Integers")
+
+
+def test_Naturals():
+    sT(S.Naturals, "Naturals")
+
+
+def test_Naturals0():
+    sT(S.Naturals0, "Naturals0")
+
+
+def test_Reals():
+    sT(S.Reals, "Reals")
+
+
+def test_matrix_expressions():
+    n = symbols('n', integer=True)
+    A = MatrixSymbol("A", n, n)
+    B = MatrixSymbol("B", n, n)
+    sT(A, "MatrixSymbol(Str('A'), Symbol('n', integer=True), Symbol('n', integer=True))")
+    sT(A*B, "MatMul(MatrixSymbol(Str('A'), Symbol('n', integer=True), Symbol('n', integer=True)), MatrixSymbol(Str('B'), Symbol('n', integer=True), Symbol('n', integer=True)))")
+    sT(A + B, "MatAdd(MatrixSymbol(Str('A'), Symbol('n', integer=True), Symbol('n', integer=True)), MatrixSymbol(Str('B'), Symbol('n', integer=True), Symbol('n', integer=True)))")
+
+
+def test_Cycle():
+    # FIXME: sT fails because Cycle is not immutable and calling srepr(Cycle(1, 2))
+    # adds keys to the Cycle dict (GH-17661)
+    #import_stmt = "from sympy.combinatorics import Cycle"
+    #sT(Cycle(1, 2), "Cycle(1, 2)", import_stmt)
+    assert srepr(Cycle(1, 2)) == "Cycle(1, 2)"
+
+
+def test_Permutation():
+    import_stmt = "from sympy.combinatorics import Permutation"
+    sT(Permutation(1, 2)(3, 4), "Permutation([0, 2, 1, 4, 3])", import_stmt, perm_cyclic=False)
+    sT(Permutation(1, 2)(3, 4), "Permutation(1, 2)(3, 4)", import_stmt, perm_cyclic=True)
+
+    with warns_deprecated_sympy():
+        old_print_cyclic = Permutation.print_cyclic
+        Permutation.print_cyclic = False
+        sT(Permutation(1, 2)(3, 4), "Permutation([0, 2, 1, 4, 3])", import_stmt)
+        Permutation.print_cyclic = old_print_cyclic
+
+def test_dict():
+    from sympy.abc import x, y, z
+    d = {}
+    assert srepr(d) == "{}"
+    d = {x: y}
+    assert srepr(d) == "{Symbol('x'): Symbol('y')}"
+    d = {x: y, y: z}
+    assert srepr(d) in (
+        "{Symbol('x'): Symbol('y'), Symbol('y'): Symbol('z')}",
+        "{Symbol('y'): Symbol('z'), Symbol('x'): Symbol('y')}",
+    )
+    d = {x: {y: z}}
+    assert srepr(d) == "{Symbol('x'): {Symbol('y'): Symbol('z')}}"
+
+def test_set():
+    from sympy.abc import x, y
+    s = set()
+    assert srepr(s) == "set()"
+    s = {x, y}
+    assert srepr(s) in ("{Symbol('x'), Symbol('y')}", "{Symbol('y'), Symbol('x')}")
+
+def test_Predicate():
+    sT(Q.even, "Q.even")
+
+def test_AppliedPredicate():
+    sT(Q.even(Symbol('z')), "AppliedPredicate(Q.even, Symbol('z'))")

lib/python3.12/site-packages/sympy/printing/tests/test_smtlib.py

@@ -0,0 +1,553 @@
+import contextlib
+import itertools
+import re
+import typing
+from enum import Enum
+from typing import Callable
+
+import sympy
+from sympy import Add, Implies, sqrt
+from sympy.core import Mul, Pow
+from sympy.core import (S, pi, symbols, Function, Rational, Integer,
+                        Symbol, Eq, Ne, Le, Lt, Gt, Ge)
+from sympy.functions import Piecewise, exp, sin, cos
+from sympy.assumptions.ask import Q
+from sympy.printing.smtlib import smtlib_code
+from sympy.testing.pytest import raises, Failed
+
+x, y, z = symbols('x,y,z')
+
+
+class _W(Enum):
+    DEFAULTING_TO_FLOAT = re.compile("Could not infer type of `.+`. Defaulting to float.", re.I)
+    WILL_NOT_DECLARE = re.compile("Non-Symbol/Function `.+` will not be declared.", re.I)
+    WILL_NOT_ASSERT = re.compile("Non-Boolean expression `.+` will not be asserted. Converting to SMTLib verbatim.", re.I)
+
+
+@contextlib.contextmanager
+def _check_warns(expected: typing.Iterable[_W]):
+    warns: typing.List[str] = []
+    log_warn = warns.append
+    yield log_warn
+
+    errors = []
+    for i, (w, e) in enumerate(itertools.zip_longest(warns, expected)):
+        if not e:
+            errors += [f"[{i}] Received unexpected warning `{w}`."]
+        elif not w:
+            errors += [f"[{i}] Did not receive expected warning `{e.name}`."]
+        elif not e.value.match(w):
+            errors += [f"[{i}] Warning `{w}` does not match expected {e.name}."]
+
+    if errors: raise Failed('\n'.join(errors))
+
+
+def test_Integer():
+    with _check_warns([_W.WILL_NOT_ASSERT] * 2) as w:
+        assert smtlib_code(Integer(67), log_warn=w) == "67"
+        assert smtlib_code(Integer(-1), log_warn=w) == "-1"
+    with _check_warns([]) as w:
+        assert smtlib_code(Integer(67)) == "67"
+        assert smtlib_code(Integer(-1)) == "-1"
+
+
+def test_Rational():
+    with _check_warns([_W.WILL_NOT_ASSERT] * 4) as w:
+        assert smtlib_code(Rational(3, 7), log_warn=w) == "(/ 3 7)"
+        assert smtlib_code(Rational(18, 9), log_warn=w) == "2"
+        assert smtlib_code(Rational(3, -7), log_warn=w) == "(/ -3 7)"
+        assert smtlib_code(Rational(-3, -7), log_warn=w) == "(/ 3 7)"
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT] * 2) as w:
+        assert smtlib_code(x + Rational(3, 7), auto_declare=False, log_warn=w) == "(+ (/ 3 7) x)"
+        assert smtlib_code(Rational(3, 7) * x, log_warn=w) == "(declare-const x Real)\n" \
+                                                              "(* (/ 3 7) x)"
+
+
+def test_Relational():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT] * 12) as w:
+        assert smtlib_code(Eq(x, y), auto_declare=False, log_warn=w) == "(assert (= x y))"
+        assert smtlib_code(Ne(x, y), auto_declare=False, log_warn=w) == "(assert (not (= x y)))"
+        assert smtlib_code(Le(x, y), auto_declare=False, log_warn=w) == "(assert (<= x y))"
+        assert smtlib_code(Lt(x, y), auto_declare=False, log_warn=w) == "(assert (< x y))"
+        assert smtlib_code(Gt(x, y), auto_declare=False, log_warn=w) == "(assert (> x y))"
+        assert smtlib_code(Ge(x, y), auto_declare=False, log_warn=w) == "(assert (>= x y))"
+
+
+def test_AppliedBinaryRelation():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT] * 12) as w:
+        assert smtlib_code(Q.eq(x, y), auto_declare=False, log_warn=w) == "(assert (= x y))"
+        assert smtlib_code(Q.ne(x, y), auto_declare=False, log_warn=w) == "(assert (not (= x y)))"
+        assert smtlib_code(Q.lt(x, y), auto_declare=False, log_warn=w) == "(assert (< x y))"
+        assert smtlib_code(Q.le(x, y), auto_declare=False, log_warn=w) == "(assert (<= x y))"
+        assert smtlib_code(Q.gt(x, y), auto_declare=False, log_warn=w) == "(assert (> x y))"
+        assert smtlib_code(Q.ge(x, y), auto_declare=False, log_warn=w) == "(assert (>= x y))"
+
+    raises(ValueError, lambda: smtlib_code(Q.complex(x), log_warn=w))
+
+
+def test_AppliedPredicate():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT] * 6) as w:
+        assert smtlib_code(Q.positive(x), auto_declare=False, log_warn=w) == "(assert (> x 0))"
+        assert smtlib_code(Q.negative(x), auto_declare=False, log_warn=w) == "(assert (< x 0))"
+        assert smtlib_code(Q.zero(x), auto_declare=False, log_warn=w) == "(assert (= x 0))"
+        assert smtlib_code(Q.nonpositive(x), auto_declare=False, log_warn=w) == "(assert (<= x 0))"
+        assert smtlib_code(Q.nonnegative(x), auto_declare=False, log_warn=w) == "(assert (>= x 0))"
+        assert smtlib_code(Q.nonzero(x), auto_declare=False, log_warn=w) == "(assert (not (= x 0)))"
+
+def test_Function():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(sin(x) ** cos(x), auto_declare=False, log_warn=w) == "(pow (sin x) (cos x))"
+
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            abs(x),
+            symbol_table={x: int, y: bool},
+            known_types={int: "INTEGER_TYPE"},
+            known_functions={sympy.Abs: "ABSOLUTE_VALUE_OF"},
+            log_warn=w
+        ) == "(declare-const x INTEGER_TYPE)\n" \
+             "(ABSOLUTE_VALUE_OF x)"
+
+    my_fun1 = Function('f1')
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            my_fun1(x),
+            symbol_table={my_fun1: Callable[[bool], float]},
+            log_warn=w
+        ) == "(declare-const x Bool)\n" \
+             "(declare-fun f1 (Bool) Real)\n" \
+             "(f1 x)"
+
+    with _check_warns([]) as w:
+        assert smtlib_code(
+            my_fun1(x),
+            symbol_table={my_fun1: Callable[[bool], bool]},
+            log_warn=w
+        ) == "(declare-const x Bool)\n" \
+             "(declare-fun f1 (Bool) Bool)\n" \
+             "(assert (f1 x))"
+
+        assert smtlib_code(
+            Eq(my_fun1(x, z), y),
+            symbol_table={my_fun1: Callable[[int, bool], bool]},
+            log_warn=w
+        ) == "(declare-const x Int)\n" \
+             "(declare-const y Bool)\n" \
+             "(declare-const z Bool)\n" \
+             "(declare-fun f1 (Int Bool) Bool)\n" \
+             "(assert (= (f1 x z) y))"
+
+        assert smtlib_code(
+            Eq(my_fun1(x, z), y),
+            symbol_table={my_fun1: Callable[[int, bool], bool]},
+            known_functions={my_fun1: "MY_KNOWN_FUN", Eq: '=='},
+            log_warn=w
+        ) == "(declare-const x Int)\n" \
+             "(declare-const y Bool)\n" \
+             "(declare-const z Bool)\n" \
+             "(assert (== (MY_KNOWN_FUN x z) y))"
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT] * 3) as w:
+        assert smtlib_code(
+            Eq(my_fun1(x, z), y),
+            known_functions={my_fun1: "MY_KNOWN_FUN", Eq: '=='},
+            log_warn=w
+        ) == "(declare-const x Real)\n" \
+             "(declare-const y Real)\n" \
+             "(declare-const z Real)\n" \
+             "(assert (== (MY_KNOWN_FUN x z) y))"
+
+
+def test_Pow():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(x ** 3, auto_declare=False, log_warn=w) == "(pow x 3)"
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(x ** (y ** 3), auto_declare=False, log_warn=w) == "(pow x (pow y 3))"
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(x ** Rational(2, 3), auto_declare=False, log_warn=w) == '(pow x (/ 2 3))'
+
+        a = Symbol('a', integer=True)
+        b = Symbol('b', real=True)
+        c = Symbol('c')
+
+        def g(x): return 2 * x
+
+        # if x=1, y=2, then expr=2.333...
+        expr = 1 / (g(a) * 3.5) ** (a - b ** a) / (a ** 2 + b)
+
+    with _check_warns([]) as w:
+        assert smtlib_code(
+            [
+                Eq(a < 2, c),
+                Eq(b > a, c),
+                c & True,
+                Eq(expr, 2 + Rational(1, 3))
+            ],
+            log_warn=w
+        ) == '(declare-const a Int)\n' \
+             '(declare-const b Real)\n' \
+             '(declare-const c Bool)\n' \
+             '(assert (= (< a 2) c))\n' \
+             '(assert (= (> b a) c))\n' \
+             '(assert c)\n' \
+             '(assert (= ' \
+             '(* (pow (* 7.0 a) (+ (pow b a) (* -1 a))) (pow (+ b (pow a 2)) -1)) ' \
+             '(/ 7 3)' \
+             '))'
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Mul(-2, c, Pow(Mul(b, b, evaluate=False), -1, evaluate=False), evaluate=False),
+            log_warn=w
+        ) == '(declare-const b Real)\n' \
+             '(declare-const c Real)\n' \
+             '(* -2 c (pow (* b b) -1))'
+
+
+def test_basic_ops():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(x * y, auto_declare=False, log_warn=w) == "(* x y)"
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(x + y, auto_declare=False, log_warn=w) == "(+ x y)"
+
+    # with _check_warns([_SmtlibWarnings.DEFAULTING_TO_FLOAT, _SmtlibWarnings.DEFAULTING_TO_FLOAT, _SmtlibWarnings.WILL_NOT_ASSERT]) as w:
+    # todo: implement re-write, currently does '(+ x (* -1 y))' instead
+    # assert smtlib_code(x - y, auto_declare=False, log_warn=w) == "(- x y)"
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(-x, auto_declare=False, log_warn=w) == "(* -1 x)"
+
+
+def test_quantifier_extensions():
+    from sympy.logic.boolalg import Boolean
+    from sympy import Interval, Tuple, sympify
+
+    # start For-all quantifier class example
+    class ForAll(Boolean):
+        def _smtlib(self, printer):
+            bound_symbol_declarations = [
+                printer._s_expr(sym.name, [
+                    printer._known_types[printer.symbol_table[sym]],
+                    Interval(start, end)
+                ]) for sym, start, end in self.limits
+            ]
+            return printer._s_expr('forall', [
+                printer._s_expr('', bound_symbol_declarations),
+                self.function
+            ])
+
+        @property
+        def bound_symbols(self):
+            return {s for s, _, _ in self.limits}
+
+        @property
+        def free_symbols(self):
+            bound_symbol_names = {s.name for s in self.bound_symbols}
+            return {
+                s for s in self.function.free_symbols
+                if s.name not in bound_symbol_names
+            }
+
+        def __new__(cls, *args):
+            limits = [sympify(a) for a in args if isinstance(a, (tuple, Tuple))]
+            function = [sympify(a) for a in args if isinstance(a, Boolean)]
+            assert len(limits) + len(function) == len(args)
+            assert len(function) == 1
+            function = function[0]
+
+            if isinstance(function, ForAll): return ForAll.__new__(
+                ForAll, *(limits + function.limits), function.function
+            )
+            inst = Boolean.__new__(cls)
+            inst._args = tuple(limits + [function])
+            inst.limits = limits
+            inst.function = function
+            return inst
+
+    # end For-All Quantifier class example
+
+    f = Function('f')
+    with _check_warns([_W.DEFAULTING_TO_FLOAT]) as w:
+        assert smtlib_code(
+            ForAll((x, -42, +21), Eq(f(x), f(x))),
+            symbol_table={f: Callable[[float], float]},
+            log_warn=w
+        ) == '(assert (forall ( (x Real [-42, 21])) true))'
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT] * 2) as w:
+        assert smtlib_code(
+            ForAll(
+                (x, -42, +21), (y, -100, 3),
+                Implies(Eq(x, y), Eq(f(x), f(y)))
+            ),
+            symbol_table={f: Callable[[float], float]},
+            log_warn=w
+        ) == '(declare-fun f (Real) Real)\n' \
+             '(assert (' \
+             'forall ( (x Real [-42, 21]) (y Real [-100, 3])) ' \
+             '(=> (= x y) (= (f x) (f y)))' \
+             '))'
+
+    a = Symbol('a', integer=True)
+    b = Symbol('b', real=True)
+    c = Symbol('c')
+
+    with _check_warns([]) as w:
+        assert smtlib_code(
+            ForAll(
+                (a, 2, 100), ForAll(
+                    (b, 2, 100),
+                    Implies(a < b, sqrt(a) < b) | c
+                )),
+            log_warn=w
+        ) == '(declare-const c Bool)\n' \
+             '(assert (forall ( (a Int [2, 100]) (b Real [2, 100])) ' \
+             '(or c (=> (< a b) (< (pow a (/ 1 2)) b)))' \
+             '))'
+
+
+def test_mix_number_mult_symbols():
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            1 / pi,
+            known_constants={pi: "MY_PI"},
+            log_warn=w
+        ) == '(pow MY_PI -1)'
+
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            [
+                Eq(pi, 3.14, evaluate=False),
+                1 / pi,
+            ],
+            known_constants={pi: "MY_PI"},
+            log_warn=w
+        ) == '(assert (= MY_PI 3.14))\n' \
+             '(pow MY_PI -1)'
+
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Add(S.Zero, S.One, S.NegativeOne, S.Half,
+                S.Exp1, S.Pi, S.GoldenRatio, evaluate=False),
+            known_constants={
+                S.Pi: 'p', S.GoldenRatio: 'g',
+                S.Exp1: 'e'
+            },
+            known_functions={
+                Add: 'plus',
+                exp: 'exp'
+            },
+            precision=3,
+            log_warn=w
+        ) == '(plus 0 1 -1 (/ 1 2) (exp 1) p g)'
+
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Add(S.Zero, S.One, S.NegativeOne, S.Half,
+                S.Exp1, S.Pi, S.GoldenRatio, evaluate=False),
+            known_constants={
+                S.Pi: 'p'
+            },
+            known_functions={
+                Add: 'plus',
+                exp: 'exp'
+            },
+            precision=3,
+            log_warn=w
+        ) == '(plus 0 1 -1 (/ 1 2) (exp 1) p 1.62)'
+
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Add(S.Zero, S.One, S.NegativeOne, S.Half,
+                S.Exp1, S.Pi, S.GoldenRatio, evaluate=False),
+            known_functions={Add: 'plus'},
+            precision=3,
+            log_warn=w
+        ) == '(plus 0 1 -1 (/ 1 2) 2.72 3.14 1.62)'
+
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Add(S.Zero, S.One, S.NegativeOne, S.Half,
+                S.Exp1, S.Pi, S.GoldenRatio, evaluate=False),
+            known_constants={S.Exp1: 'e'},
+            known_functions={Add: 'plus'},
+            precision=3,
+            log_warn=w
+        ) == '(plus 0 1 -1 (/ 1 2) e 3.14 1.62)'
+
+
+def test_boolean():
+    with _check_warns([]) as w:
+        assert smtlib_code(x & y, log_warn=w) == '(declare-const x Bool)\n' \
+                                                 '(declare-const y Bool)\n' \
+                                                 '(assert (and x y))'
+        assert smtlib_code(x | y, log_warn=w) == '(declare-const x Bool)\n' \
+                                                 '(declare-const y Bool)\n' \
+                                                 '(assert (or x y))'
+        assert smtlib_code(~x, log_warn=w) == '(declare-const x Bool)\n' \
+                                              '(assert (not x))'
+        assert smtlib_code(x & y & z, log_warn=w) == '(declare-const x Bool)\n' \
+                                                     '(declare-const y Bool)\n' \
+                                                     '(declare-const z Bool)\n' \
+                                                     '(assert (and x y z))'
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT]) as w:
+        assert smtlib_code((x & ~y) | (z > 3), log_warn=w) == '(declare-const x Bool)\n' \
+                                                              '(declare-const y Bool)\n' \
+                                                              '(declare-const z Real)\n' \
+                                                              '(assert (or (> z 3) (and x (not y))))'
+
+    f = Function('f')
+    g = Function('g')
+    h = Function('h')
+    with _check_warns([_W.DEFAULTING_TO_FLOAT]) as w:
+        assert smtlib_code(
+            [Gt(f(x), y),
+             Lt(y, g(z))],
+            symbol_table={
+                f: Callable[[bool], int], g: Callable[[bool], int],
+            }, log_warn=w
+        ) == '(declare-const x Bool)\n' \
+             '(declare-const y Real)\n' \
+             '(declare-const z Bool)\n' \
+             '(declare-fun f (Bool) Int)\n' \
+             '(declare-fun g (Bool) Int)\n' \
+             '(assert (> (f x) y))\n' \
+             '(assert (< y (g z)))'
+
+    with _check_warns([]) as w:
+        assert smtlib_code(
+            [Eq(f(x), y),
+             Lt(y, g(z))],
+            symbol_table={
+                f: Callable[[bool], int], g: Callable[[bool], int],
+            }, log_warn=w
+        ) == '(declare-const x Bool)\n' \
+             '(declare-const y Int)\n' \
+             '(declare-const z Bool)\n' \
+             '(declare-fun f (Bool) Int)\n' \
+             '(declare-fun g (Bool) Int)\n' \
+             '(assert (= (f x) y))\n' \
+             '(assert (< y (g z)))'
+
+    with _check_warns([]) as w:
+        assert smtlib_code(
+            [Eq(f(x), y),
+             Eq(g(f(x)), z),
+             Eq(h(g(f(x))), x)],
+            symbol_table={
+                f: Callable[[float], int],
+                g: Callable[[int], bool],
+                h: Callable[[bool], float]
+            },
+            log_warn=w
+        ) == '(declare-const x Real)\n' \
+             '(declare-const y Int)\n' \
+             '(declare-const z Bool)\n' \
+             '(declare-fun f (Real) Int)\n' \
+             '(declare-fun g (Int) Bool)\n' \
+             '(declare-fun h (Bool) Real)\n' \
+             '(assert (= (f x) y))\n' \
+             '(assert (= (g (f x)) z))\n' \
+             '(assert (= (h (g (f x))) x))'
+
+
+# todo: make smtlib_code support arrays
+# def test_containers():
+#     assert julia_code([1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]) == \
+#            "Any[1, 2, 3, Any[4, 5, Any[6, 7]], 8, Any[9, 10], 11]"
+#     assert julia_code((1, 2, (3, 4))) == "(1, 2, (3, 4))"
+#     assert julia_code([1]) == "Any[1]"
+#     assert julia_code((1,)) == "(1,)"
+#     assert julia_code(Tuple(*[1, 2, 3])) == "(1, 2, 3)"
+#     assert julia_code((1, x * y, (3, x ** 2))) == "(1, x .* y, (3, x .^ 2))"
+#     # scalar, matrix, empty matrix and empty list
+#     assert julia_code((1, eye(3), Matrix(0, 0, []), [])) == "(1, [1 0 0;\n0 1 0;\n0 0 1], zeros(0, 0), Any[])"
+
+def test_smtlib_piecewise():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Piecewise((x, x < 1),
+                      (x ** 2, True)),
+            auto_declare=False,
+            log_warn=w
+        ) == '(ite (< x 1) x (pow x 2))'
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Piecewise((x ** 2, x < 1),
+                      (x ** 3, x < 2),
+                      (x ** 4, x < 3),
+                      (x ** 5, True)),
+            auto_declare=False,
+            log_warn=w
+        ) == '(ite (< x 1) (pow x 2) ' \
+             '(ite (< x 2) (pow x 3) ' \
+             '(ite (< x 3) (pow x 4) ' \
+             '(pow x 5))))'
+
+    # Check that Piecewise without a True (default) condition error
+    expr = Piecewise((x, x < 1), (x ** 2, x > 1), (sin(x), x > 0))
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        raises(AssertionError, lambda: smtlib_code(expr, log_warn=w))
+
+
+def test_smtlib_piecewise_times_const():
+    pw = Piecewise((x, x < 1), (x ** 2, True))
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(2 * pw, log_warn=w) == '(declare-const x Real)\n(* 2 (ite (< x 1) x (pow x 2)))'
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(pw / x, log_warn=w) == '(declare-const x Real)\n(* (pow x -1) (ite (< x 1) x (pow x 2)))'
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(pw / (x * y), log_warn=w) == '(declare-const x Real)\n(declare-const y Real)\n(* (pow x -1) (pow y -1) (ite (< x 1) x (pow x 2)))'
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(pw / 3, log_warn=w) == '(declare-const x Real)\n(* (/ 1 3) (ite (< x 1) x (pow x 2)))'
+
+
+# todo: make smtlib_code support arrays / matrices ?
+# def test_smtlib_matrix_assign_to():
+#     A = Matrix([[1, 2, 3]])
+#     assert smtlib_code(A, assign_to='a') == "a = [1 2 3]"
+#     A = Matrix([[1, 2], [3, 4]])
+#     assert smtlib_code(A, assign_to='A') == "A = [1 2;\n3 4]"
+
+# def test_julia_matrix_1x1():
+#     A = Matrix([[3]])
+#     B = MatrixSymbol('B', 1, 1)
+#     C = MatrixSymbol('C', 1, 2)
+#     assert julia_code(A, assign_to=B) == "B = [3]"
+#     raises(ValueError, lambda: julia_code(A, assign_to=C))
+
+# def test_julia_matrix_elements():
+#     A = Matrix([[x, 2, x * y]])
+#     assert julia_code(A[0, 0] ** 2 + A[0, 1] + A[0, 2]) == "x .^ 2 + x .* y + 2"
+#     A = MatrixSymbol('AA', 1, 3)
+#     assert julia_code(A) == "AA"
+#     assert julia_code(A[0, 0] ** 2 + sin(A[0, 1]) + A[0, 2]) == \
+#            "sin(AA[1,2]) + AA[1,1] .^ 2 + AA[1,3]"
+#     assert julia_code(sum(A)) == "AA[1,1] + AA[1,2] + AA[1,3]"
+
+def test_smtlib_boolean():
+    with _check_warns([]) as w:
+        assert smtlib_code(True, auto_assert=False, log_warn=w) == 'true'
+        assert smtlib_code(True, log_warn=w) == '(assert true)'
+        assert smtlib_code(S.true, log_warn=w) == '(assert true)'
+        assert smtlib_code(S.false, log_warn=w) == '(assert false)'
+        assert smtlib_code(False, log_warn=w) == '(assert false)'
+        assert smtlib_code(False, auto_assert=False, log_warn=w) == 'false'
+
+
+def test_not_supported():
+    f = Function('f')
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        raises(KeyError, lambda: smtlib_code(f(x).diff(x), symbol_table={f: Callable[[float], float]}, log_warn=w))
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        raises(KeyError, lambda: smtlib_code(S.ComplexInfinity, log_warn=w))
+
+
+def test_Float():
+    assert smtlib_code(0.0) == "0.0"
+    assert smtlib_code(0.000000000000000003) == '(* 3.0 (pow 10 -18))'
+    assert smtlib_code(5.3) == "5.3"

lib/python3.12/site-packages/sympy/printing/tests/test_str.py

@@ -0,0 +1,1199 @@
+from sympy import MatAdd
+from sympy.algebras.quaternion import Quaternion
+from sympy.assumptions.ask import Q
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.combinatorics.partitions import Partition
+from sympy.concrete.summations import (Sum, summation)
+from sympy.core.add import Add
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.expr import UnevaluatedExpr, Expr
+from sympy.core.function import (Derivative, Function, Lambda, Subs, WildFunction)
+from sympy.core.mul import Mul
+from sympy.core import (Catalan, EulerGamma, GoldenRatio, TribonacciConstant)
+from sympy.core.numbers import (E, Float, I, Integer, Rational, nan, oo, pi, zoo)
+from sympy.core.parameters import _exp_is_pow
+from sympy.core.power import Pow
+from sympy.core.relational import (Eq, Rel, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, Wild, symbols)
+from sympy.functions.combinatorial.factorials import (factorial, factorial2, subfactorial)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.delta_functions import Heaviside
+from sympy.functions.special.zeta_functions import zeta
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import (Equivalent, false, true, Xor)
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions import Identity
+from sympy.matrices.expressions.slice import MatrixSlice
+from sympy.matrices import SparseMatrix
+from sympy.polys.polytools import factor
+from sympy.series.limits import Limit
+from sympy.series.order import O
+from sympy.sets.sets import (Complement, FiniteSet, Interval, SymmetricDifference)
+from sympy.stats import (Covariance, Expectation, Probability, Variance)
+from sympy.stats.rv import RandomSymbol
+from sympy.external import import_module
+from sympy.physics.control.lti import TransferFunction, Series, Parallel, \
+    Feedback, TransferFunctionMatrix, MIMOSeries, MIMOParallel, MIMOFeedback
+from sympy.physics.units import second, joule
+from sympy.polys import (Poly, rootof, RootSum, groebner, ring, field, ZZ, QQ,
+    ZZ_I, QQ_I, lex, grlex)
+from sympy.geometry import Point, Circle, Polygon, Ellipse, Triangle
+from sympy.tensor import NDimArray
+from sympy.tensor.array.expressions.array_expressions import ArraySymbol, ArrayElement
+
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+from sympy.printing import sstr, sstrrepr, StrPrinter
+from sympy.physics.quantum.trace import Tr
+
+x, y, z, w, t = symbols('x,y,z,w,t')
+d = Dummy('d')
+
+
+def test_printmethod():
+    class R(Abs):
+        def _sympystr(self, printer):
+            return "foo(%s)" % printer._print(self.args[0])
+    assert sstr(R(x)) == "foo(x)"
+
+    class R(Abs):
+        def _sympystr(self, printer):
+            return "foo"
+    assert sstr(R(x)) == "foo"
+
+
+def test_Abs():
+    assert str(Abs(x)) == "Abs(x)"
+    assert str(Abs(Rational(1, 6))) == "1/6"
+    assert str(Abs(Rational(-1, 6))) == "1/6"
+
+
+def test_Add():
+    assert str(x + y) == "x + y"
+    assert str(x + 1) == "x + 1"
+    assert str(x + x**2) == "x**2 + x"
+    assert str(Add(0, 1, evaluate=False)) == "0 + 1"
+    assert str(Add(0, 0, 1, evaluate=False)) == "0 + 0 + 1"
+    assert str(1.0*x) == "1.0*x"
+    assert str(5 + x + y + x*y + x**2 + y**2) == "x**2 + x*y + x + y**2 + y + 5"
+    assert str(1 + x + x**2/2 + x**3/3) == "x**3/3 + x**2/2 + x + 1"
+    assert str(2*x - 7*x**2 + 2 + 3*y) == "-7*x**2 + 2*x + 3*y + 2"
+    assert str(x - y) == "x - y"
+    assert str(2 - x) == "2 - x"
+    assert str(x - 2) == "x - 2"
+    assert str(x - y - z - w) == "-w + x - y - z"
+    assert str(x - z*y**2*z*w) == "-w*y**2*z**2 + x"
+    assert str(x - 1*y*x*y) == "-x*y**2 + x"
+    assert str(sin(x).series(x, 0, 15)) == "x - x**3/6 + x**5/120 - x**7/5040 + x**9/362880 - x**11/39916800 + x**13/6227020800 + O(x**15)"
+    assert str(Add(Add(-w, x, evaluate=False), Add(-y, z,  evaluate=False),  evaluate=False)) == "(-w + x) + (-y + z)"
+    assert str(Add(Add(-x, -y, evaluate=False), -z, evaluate=False)) == "-z + (-x - y)"
+    assert str(Add(Add(Add(-x, -y, evaluate=False), -z, evaluate=False), -t, evaluate=False)) == "-t + (-z + (-x - y))"
+
+
+def test_Catalan():
+    assert str(Catalan) == "Catalan"
+
+
+def test_ComplexInfinity():
+    assert str(zoo) == "zoo"
+
+
+def test_Derivative():
+    assert str(Derivative(x, y)) == "Derivative(x, y)"
+    assert str(Derivative(x**2, x, evaluate=False)) == "Derivative(x**2, x)"
+    assert str(Derivative(
+        x**2/y, x, y, evaluate=False)) == "Derivative(x**2/y, x, y)"
+
+
+def test_dict():
+    assert str({1: 1 + x}) == sstr({1: 1 + x}) == "{1: x + 1}"
+    assert str({1: x**2, 2: y*x}) in ("{1: x**2, 2: x*y}", "{2: x*y, 1: x**2}")
+    assert sstr({1: x**2, 2: y*x}) == "{1: x**2, 2: x*y}"
+
+
+def test_Dict():
+    assert str(Dict({1: 1 + x})) == sstr({1: 1 + x}) == "{1: x + 1}"
+    assert str(Dict({1: x**2, 2: y*x})) in (
+        "{1: x**2, 2: x*y}", "{2: x*y, 1: x**2}")
+    assert sstr(Dict({1: x**2, 2: y*x})) == "{1: x**2, 2: x*y}"
+
+
+def test_Dummy():
+    assert str(d) == "_d"
+    assert str(d + x) == "_d + x"
+
+
+def test_EulerGamma():
+    assert str(EulerGamma) == "EulerGamma"
+
+
+def test_Exp():
+    assert str(E) == "E"
+    with _exp_is_pow(True):
+        assert str(exp(x)) == "E**x"
+
+
+def test_factorial():
+    n = Symbol('n', integer=True)
+    assert str(factorial(-2)) == "zoo"
+    assert str(factorial(0)) == "1"
+    assert str(factorial(7)) == "5040"
+    assert str(factorial(n)) == "factorial(n)"
+    assert str(factorial(2*n)) == "factorial(2*n)"
+    assert str(factorial(factorial(n))) == 'factorial(factorial(n))'
+    assert str(factorial(factorial2(n))) == 'factorial(factorial2(n))'
+    assert str(factorial2(factorial(n))) == 'factorial2(factorial(n))'
+    assert str(factorial2(factorial2(n))) == 'factorial2(factorial2(n))'
+    assert str(subfactorial(3)) == "2"
+    assert str(subfactorial(n)) == "subfactorial(n)"
+    assert str(subfactorial(2*n)) == "subfactorial(2*n)"
+
+
+def test_Function():
+    f = Function('f')
+    fx = f(x)
+    w = WildFunction('w')
+    assert str(f) == "f"
+    assert str(fx) == "f(x)"
+    assert str(w) == "w_"
+
+
+def test_Geometry():
+    assert sstr(Point(0, 0)) == 'Point2D(0, 0)'
+    assert sstr(Circle(Point(0, 0), 3)) == 'Circle(Point2D(0, 0), 3)'
+    assert sstr(Ellipse(Point(1, 2), 3, 4)) == 'Ellipse(Point2D(1, 2), 3, 4)'
+    assert sstr(Triangle(Point(1, 1), Point(7, 8), Point(0, -1))) == \
+        'Triangle(Point2D(1, 1), Point2D(7, 8), Point2D(0, -1))'
+    assert sstr(Polygon(Point(5, 6), Point(-2, -3), Point(0, 0), Point(4, 7))) == \
+        'Polygon(Point2D(5, 6), Point2D(-2, -3), Point2D(0, 0), Point2D(4, 7))'
+    assert sstr(Triangle(Point(0, 0), Point(1, 0), Point(0, 1)), sympy_integers=True) == \
+        'Triangle(Point2D(S(0), S(0)), Point2D(S(1), S(0)), Point2D(S(0), S(1)))'
+    assert sstr(Ellipse(Point(1, 2), 3, 4), sympy_integers=True) == \
+        'Ellipse(Point2D(S(1), S(2)), S(3), S(4))'
+
+
+def test_GoldenRatio():
+    assert str(GoldenRatio) == "GoldenRatio"
+
+
+def test_Heaviside():
+    assert str(Heaviside(x)) == str(Heaviside(x, S.Half)) == "Heaviside(x)"
+    assert str(Heaviside(x, 1)) == "Heaviside(x, 1)"
+
+
+def test_TribonacciConstant():
+    assert str(TribonacciConstant) == "TribonacciConstant"
+
+
+def test_ImaginaryUnit():
+    assert str(I) == "I"
+
+
+def test_Infinity():
+    assert str(oo) == "oo"
+    assert str(oo*I) == "oo*I"
+
+
+def test_Integer():
+    assert str(Integer(-1)) == "-1"
+    assert str(Integer(1)) == "1"
+    assert str(Integer(-3)) == "-3"
+    assert str(Integer(0)) == "0"
+    assert str(Integer(25)) == "25"
+
+
+def test_Integral():
+    assert str(Integral(sin(x), y)) == "Integral(sin(x), y)"
+    assert str(Integral(sin(x), (y, 0, 1))) == "Integral(sin(x), (y, 0, 1))"
+
+
+def test_Interval():
+    n = (S.NegativeInfinity, 1, 2, S.Infinity)
+    for i in range(len(n)):
+        for j in range(i + 1, len(n)):
+            for l in (True, False):
+                for r in (True, False):
+                    ival = Interval(n[i], n[j], l, r)
+                    assert S(str(ival)) == ival
+
+
+def test_AccumBounds():
+    a = Symbol('a', real=True)
+    assert str(AccumBounds(0, a)) == "AccumBounds(0, a)"
+    assert str(AccumBounds(0, 1)) == "AccumBounds(0, 1)"
+
+
+def test_Lambda():
+    assert str(Lambda(d, d**2)) == "Lambda(_d, _d**2)"
+    # issue 2908
+    assert str(Lambda((), 1)) == "Lambda((), 1)"
+    assert str(Lambda((), x)) == "Lambda((), x)"
+    assert str(Lambda((x, y), x+y)) == "Lambda((x, y), x + y)"
+    assert str(Lambda(((x, y),), x+y)) == "Lambda(((x, y),), x + y)"
+
+
+def test_Limit():
+    assert str(Limit(sin(x)/x, x, y)) == "Limit(sin(x)/x, x, y, dir='+')"
+    assert str(Limit(1/x, x, 0)) == "Limit(1/x, x, 0, dir='+')"
+    assert str(
+        Limit(sin(x)/x, x, y, dir="-")) == "Limit(sin(x)/x, x, y, dir='-')"
+
+
+def test_list():
+    assert str([x]) == sstr([x]) == "[x]"
+    assert str([x**2, x*y + 1]) == sstr([x**2, x*y + 1]) == "[x**2, x*y + 1]"
+    assert str([x**2, [y + x]]) == sstr([x**2, [y + x]]) == "[x**2, [x + y]]"
+
+
+def test_Matrix_str():
+    M = Matrix([[x**+1, 1], [y, x + y]])
+    assert str(M) == "Matrix([[x, 1], [y, x + y]])"
+    assert sstr(M) == "Matrix([\n[x,     1],\n[y, x + y]])"
+    M = Matrix([[1]])
+    assert str(M) == sstr(M) == "Matrix([[1]])"
+    M = Matrix([[1, 2]])
+    assert str(M) == sstr(M) ==  "Matrix([[1, 2]])"
+    M = Matrix()
+    assert str(M) == sstr(M) == "Matrix(0, 0, [])"
+    M = Matrix(0, 1, lambda i, j: 0)
+    assert str(M) == sstr(M) == "Matrix(0, 1, [])"
+
+
+def test_Mul():
+    assert str(x/y) == "x/y"
+    assert str(y/x) == "y/x"
+    assert str(x/y/z) == "x/(y*z)"
+    assert str((x + 1)/(y + 2)) == "(x + 1)/(y + 2)"
+    assert str(2*x/3) == '2*x/3'
+    assert str(-2*x/3) == '-2*x/3'
+    assert str(-1.0*x) == '-1.0*x'
+    assert str(1.0*x) == '1.0*x'
+    assert str(Mul(0, 1, evaluate=False)) == '0*1'
+    assert str(Mul(1, 0, evaluate=False)) == '1*0'
+    assert str(Mul(1, 1, evaluate=False)) == '1*1'
+    assert str(Mul(1, 1, 1, evaluate=False)) == '1*1*1'
+    assert str(Mul(1, 2, evaluate=False)) == '1*2'
+    assert str(Mul(1, S.Half, evaluate=False)) == '1*(1/2)'
+    assert str(Mul(1, 1, S.Half, evaluate=False)) == '1*1*(1/2)'
+    assert str(Mul(1, 1, 2, 3, x, evaluate=False)) == '1*1*2*3*x'
+    assert str(Mul(1, -1, evaluate=False)) == '1*(-1)'
+    assert str(Mul(-1, 1, evaluate=False)) == '-1*1'
+    assert str(Mul(4, 3, 2, 1, 0, y, x, evaluate=False)) == '4*3*2*1*0*y*x'
+    assert str(Mul(4, 3, 2, 1+z, 0, y, x, evaluate=False)) == '4*3*2*(z + 1)*0*y*x'
+    assert str(Mul(Rational(2, 3), Rational(5, 7), evaluate=False)) == '(2/3)*(5/7)'
+    # For issue 14160
+    assert str(Mul(-2, x, Pow(Mul(y,y,evaluate=False), -1, evaluate=False),
+                                                evaluate=False)) == '-2*x/(y*y)'
+    # issue 21537
+    assert str(Mul(x, Pow(1/y, -1, evaluate=False), evaluate=False)) == 'x/(1/y)'
+
+    # Issue 24108
+    from sympy.core.parameters import evaluate
+    with evaluate(False):
+        assert str(Mul(Pow(Integer(2), Integer(-1)), Add(Integer(-1), Mul(Integer(-1), Integer(1))))) == "(-1 - 1*1)/2"
+
+    class CustomClass1(Expr):
+        is_commutative = True
+
+    class CustomClass2(Expr):
+        is_commutative = True
+    cc1 = CustomClass1()
+    cc2 = CustomClass2()
+    assert str(Rational(2)*cc1) == '2*CustomClass1()'
+    assert str(cc1*Rational(2)) == '2*CustomClass1()'
+    assert str(cc1*Float("1.5")) == '1.5*CustomClass1()'
+    assert str(cc2*Rational(2)) == '2*CustomClass2()'
+    assert str(cc2*Rational(2)*cc1) == '2*CustomClass1()*CustomClass2()'
+    assert str(cc1*Rational(2)*cc2) == '2*CustomClass1()*CustomClass2()'
+
+
+def test_NaN():
+    assert str(nan) == "nan"
+
+
+def test_NegativeInfinity():
+    assert str(-oo) == "-oo"
+
+def test_Order():
+    assert str(O(x)) == "O(x)"
+    assert str(O(x**2)) == "O(x**2)"
+    assert str(O(x*y)) == "O(x*y, x, y)"
+    assert str(O(x, x)) == "O(x)"
+    assert str(O(x, (x, 0))) == "O(x)"
+    assert str(O(x, (x, oo))) == "O(x, (x, oo))"
+    assert str(O(x, x, y)) == "O(x, x, y)"
+    assert str(O(x, x, y)) == "O(x, x, y)"
+    assert str(O(x, (x, oo), (y, oo))) == "O(x, (x, oo), (y, oo))"
+
+
+def test_Permutation_Cycle():
+    from sympy.combinatorics import Permutation, Cycle
+
+    # general principle: economically, canonically show all moved elements
+    # and the size of the permutation.
+
+    for p, s in [
+        (Cycle(),
+        '()'),
+        (Cycle(2),
+        '(2)'),
+        (Cycle(2, 1),
+        '(1 2)'),
+        (Cycle(1, 2)(5)(6, 7)(10),
+        '(1 2)(6 7)(10)'),
+        (Cycle(3, 4)(1, 2)(3, 4),
+        '(1 2)(4)'),
+    ]:
+        assert sstr(p) == s
+
+    for p, s in [
+        (Permutation([]),
+        'Permutation([])'),
+        (Permutation([], size=1),
+        'Permutation([0])'),
+        (Permutation([], size=2),
+        'Permutation([0, 1])'),
+        (Permutation([], size=10),
+        'Permutation([], size=10)'),
+        (Permutation([1, 0, 2]),
+        'Permutation([1, 0, 2])'),
+        (Permutation([1, 0, 2, 3, 4, 5]),
+        'Permutation([1, 0], size=6)'),
+        (Permutation([1, 0, 2, 3, 4, 5], size=10),
+        'Permutation([1, 0], size=10)'),
+    ]:
+        assert sstr(p, perm_cyclic=False) == s
+
+    for p, s in [
+        (Permutation([]),
+        '()'),
+        (Permutation([], size=1),
+        '(0)'),
+        (Permutation([], size=2),
+        '(1)'),
+        (Permutation([], size=10),
+        '(9)'),
+        (Permutation([1, 0, 2]),
+        '(2)(0 1)'),
+        (Permutation([1, 0, 2, 3, 4, 5]),
+        '(5)(0 1)'),
+        (Permutation([1, 0, 2, 3, 4, 5], size=10),
+        '(9)(0 1)'),
+        (Permutation([0, 1, 3, 2, 4, 5], size=10),
+        '(9)(2 3)'),
+    ]:
+        assert sstr(p) == s
+
+
+    with warns_deprecated_sympy():
+        old_print_cyclic = Permutation.print_cyclic
+        Permutation.print_cyclic = False
+        assert sstr(Permutation([1, 0, 2])) == 'Permutation([1, 0, 2])'
+        Permutation.print_cyclic = old_print_cyclic
+
+def test_Pi():
+    assert str(pi) == "pi"
+
+
+def test_Poly():
+    assert str(Poly(0, x)) == "Poly(0, x, domain='ZZ')"
+    assert str(Poly(1, x)) == "Poly(1, x, domain='ZZ')"
+    assert str(Poly(x, x)) == "Poly(x, x, domain='ZZ')"
+
+    assert str(Poly(2*x + 1, x)) == "Poly(2*x + 1, x, domain='ZZ')"
+    assert str(Poly(2*x - 1, x)) == "Poly(2*x - 1, x, domain='ZZ')"
+
+    assert str(Poly(-1, x)) == "Poly(-1, x, domain='ZZ')"
+    assert str(Poly(-x, x)) == "Poly(-x, x, domain='ZZ')"
+
+    assert str(Poly(-2*x + 1, x)) == "Poly(-2*x + 1, x, domain='ZZ')"
+    assert str(Poly(-2*x - 1, x)) == "Poly(-2*x - 1, x, domain='ZZ')"
+
+    assert str(Poly(x - 1, x)) == "Poly(x - 1, x, domain='ZZ')"
+    assert str(Poly(2*x + x**5, x)) == "Poly(x**5 + 2*x, x, domain='ZZ')"
+
+    assert str(Poly(3**(2*x), 3**x)) == "Poly((3**x)**2, 3**x, domain='ZZ')"
+    assert str(Poly((x**2)**x)) == "Poly(((x**2)**x), (x**2)**x, domain='ZZ')"
+
+    assert str(Poly((x + y)**3, (x + y), expand=False)
+                ) == "Poly((x + y)**3, x + y, domain='ZZ')"
+    assert str(Poly((x - 1)**2, (x - 1), expand=False)
+                ) == "Poly((x - 1)**2, x - 1, domain='ZZ')"
+
+    assert str(
+        Poly(x**2 + 1 + y, x)) == "Poly(x**2 + y + 1, x, domain='ZZ[y]')"
+    assert str(
+        Poly(x**2 - 1 + y, x)) == "Poly(x**2 + y - 1, x, domain='ZZ[y]')"
+
+    assert str(Poly(x**2 + I*x, x)) == "Poly(x**2 + I*x, x, domain='ZZ_I')"
+    assert str(Poly(x**2 - I*x, x)) == "Poly(x**2 - I*x, x, domain='ZZ_I')"
+
+    assert str(Poly(-x*y*z + x*y - 1, x, y, z)
+               ) == "Poly(-x*y*z + x*y - 1, x, y, z, domain='ZZ')"
+    assert str(Poly(-w*x**21*y**7*z + (1 + w)*z**3 - 2*x*z + 1, x, y, z)) == \
+        "Poly(-w*x**21*y**7*z - 2*x*z + (w + 1)*z**3 + 1, x, y, z, domain='ZZ[w]')"
+
+    assert str(Poly(x**2 + 1, x, modulus=2)) == "Poly(x**2 + 1, x, modulus=2)"
+    assert str(Poly(2*x**2 + 3*x + 4, x, modulus=17)) == "Poly(2*x**2 + 3*x + 4, x, modulus=17)"
+
+
+def test_PolyRing():
+    assert str(ring("x", ZZ, lex)[0]) == "Polynomial ring in x over ZZ with lex order"
+    assert str(ring("x,y", QQ, grlex)[0]) == "Polynomial ring in x, y over QQ with grlex order"
+    assert str(ring("x,y,z", ZZ["t"], lex)[0]) == "Polynomial ring in x, y, z over ZZ[t] with lex order"
+
+
+def test_FracField():
+    assert str(field("x", ZZ, lex)[0]) == "Rational function field in x over ZZ with lex order"
+    assert str(field("x,y", QQ, grlex)[0]) == "Rational function field in x, y over QQ with grlex order"
+    assert str(field("x,y,z", ZZ["t"], lex)[0]) == "Rational function field in x, y, z over ZZ[t] with lex order"
+
+
+def test_PolyElement():
+    Ruv, u,v = ring("u,v", ZZ)
+    Rxyz, x,y,z = ring("x,y,z", Ruv)
+    Rx_zzi, xz = ring("x", ZZ_I)
+
+    assert str(x - x) == "0"
+    assert str(x - 1) == "x - 1"
+    assert str(x + 1) == "x + 1"
+    assert str(x**2) == "x**2"
+    assert str(x**(-2)) == "x**(-2)"
+    assert str(x**QQ(1, 2)) == "x**(1/2)"
+
+    assert str((u**2 + 3*u*v + 1)*x**2*y + u + 1) == "(u**2 + 3*u*v + 1)*x**2*y + u + 1"
+    assert str((u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x) == "(u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x"
+    assert str((u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x + 1) == "(u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x + 1"
+    assert str((-u**2 + 3*u*v - 1)*x**2*y - (u + 1)*x - 1) == "-(u**2 - 3*u*v + 1)*x**2*y - (u + 1)*x - 1"
+
+    assert str(-(v**2 + v + 1)*x + 3*u*v + 1) == "-(v**2 + v + 1)*x + 3*u*v + 1"
+    assert str(-(v**2 + v + 1)*x - 3*u*v + 1) == "-(v**2 + v + 1)*x - 3*u*v + 1"
+
+    assert str((1+I)*xz + 2) == "(1 + 1*I)*x + (2 + 0*I)"
+
+
+def test_FracElement():
+    Fuv, u,v = field("u,v", ZZ)
+    Fxyzt, x,y,z,t = field("x,y,z,t", Fuv)
+    Rx_zzi, xz = field("x", QQ_I)
+    i = QQ_I(0, 1)
+
+    assert str(x - x) == "0"
+    assert str(x - 1) == "x - 1"
+    assert str(x + 1) == "x + 1"
+
+    assert str(x/3) == "x/3"
+    assert str(x/z) == "x/z"
+    assert str(x*y/z) == "x*y/z"
+    assert str(x/(z*t)) == "x/(z*t)"
+    assert str(x*y/(z*t)) == "x*y/(z*t)"
+
+    assert str((x - 1)/y) == "(x - 1)/y"
+    assert str((x + 1)/y) == "(x + 1)/y"
+    assert str((-x - 1)/y) == "(-x - 1)/y"
+    assert str((x + 1)/(y*z)) == "(x + 1)/(y*z)"
+    assert str(-y/(x + 1)) == "-y/(x + 1)"
+    assert str(y*z/(x + 1)) == "y*z/(x + 1)"
+
+    assert str(((u + 1)*x*y + 1)/((v - 1)*z - 1)) == "((u + 1)*x*y + 1)/((v - 1)*z - 1)"
+    assert str(((u + 1)*x*y + 1)/((v - 1)*z - t*u*v - 1)) == "((u + 1)*x*y + 1)/((v - 1)*z - u*v*t - 1)"
+
+    assert str((1+i)/xz) == "(1 + 1*I)/x"
+    assert str(((1+i)*xz - i)/xz) == "((1 + 1*I)*x + (0 + -1*I))/x"
+
+
+def test_GaussianInteger():
+    assert str(ZZ_I(1, 0)) == "1"
+    assert str(ZZ_I(-1, 0)) == "-1"
+    assert str(ZZ_I(0, 1)) == "I"
+    assert str(ZZ_I(0, -1)) == "-I"
+    assert str(ZZ_I(0, 2)) == "2*I"
+    assert str(ZZ_I(0, -2)) == "-2*I"
+    assert str(ZZ_I(1, 1)) == "1 + I"
+    assert str(ZZ_I(-1, -1)) == "-1 - I"
+    assert str(ZZ_I(-1, -2)) == "-1 - 2*I"
+
+
+def test_GaussianRational():
+    assert str(QQ_I(1, 0)) == "1"
+    assert str(QQ_I(QQ(2, 3), 0)) == "2/3"
+    assert str(QQ_I(0, QQ(2, 3))) == "2*I/3"
+    assert str(QQ_I(QQ(1, 2), QQ(-2, 3))) == "1/2 - 2*I/3"
+
+
+def test_Pow():
+    assert str(x**-1) == "1/x"
+    assert str(x**-2) == "x**(-2)"
+    assert str(x**2) == "x**2"
+    assert str((x + y)**-1) == "1/(x + y)"
+    assert str((x + y)**-2) == "(x + y)**(-2)"
+    assert str((x + y)**2) == "(x + y)**2"
+    assert str((x + y)**(1 + x)) == "(x + y)**(x + 1)"
+    assert str(x**Rational(1, 3)) == "x**(1/3)"
+    assert str(1/x**Rational(1, 3)) == "x**(-1/3)"
+    assert str(sqrt(sqrt(x))) == "x**(1/4)"
+    # not the same as x**-1
+    assert str(x**-1.0) == 'x**(-1.0)'
+    # see issue #2860
+    assert str(Pow(S(2), -1.0, evaluate=False)) == '2**(-1.0)'
+
+
+def test_sqrt():
+    assert str(sqrt(x)) == "sqrt(x)"
+    assert str(sqrt(x**2)) == "sqrt(x**2)"
+    assert str(1/sqrt(x)) == "1/sqrt(x)"
+    assert str(1/sqrt(x**2)) == "1/sqrt(x**2)"
+    assert str(y/sqrt(x)) == "y/sqrt(x)"
+    assert str(x**0.5) == "x**0.5"
+    assert str(1/x**0.5) == "x**(-0.5)"
+
+
+def test_Rational():
+    n1 = Rational(1, 4)
+    n2 = Rational(1, 3)
+    n3 = Rational(2, 4)
+    n4 = Rational(2, -4)
+    n5 = Rational(0)
+    n7 = Rational(3)
+    n8 = Rational(-3)
+    assert str(n1*n2) == "1/12"
+    assert str(n1*n2) == "1/12"
+    assert str(n3) == "1/2"
+    assert str(n1*n3) == "1/8"
+    assert str(n1 + n3) == "3/4"
+    assert str(n1 + n2) == "7/12"
+    assert str(n1 + n4) == "-1/4"
+    assert str(n4*n4) == "1/4"
+    assert str(n4 + n2) == "-1/6"
+    assert str(n4 + n5) == "-1/2"
+    assert str(n4*n5) == "0"
+    assert str(n3 + n4) == "0"
+    assert str(n1**n7) == "1/64"
+    assert str(n2**n7) == "1/27"
+    assert str(n2**n8) == "27"
+    assert str(n7**n8) == "1/27"
+    assert str(Rational("-25")) == "-25"
+    assert str(Rational("1.25")) == "5/4"
+    assert str(Rational("-2.6e-2")) == "-13/500"
+    assert str(S("25/7")) == "25/7"
+    assert str(S("-123/569")) == "-123/569"
+    assert str(S("0.1[23]", rational=1)) == "61/495"
+    assert str(S("5.1[666]", rational=1)) == "31/6"
+    assert str(S("-5.1[666]", rational=1)) == "-31/6"
+    assert str(S("0.[9]", rational=1)) == "1"
+    assert str(S("-0.[9]", rational=1)) == "-1"
+
+    assert str(sqrt(Rational(1, 4))) == "1/2"
+    assert str(sqrt(Rational(1, 36))) == "1/6"
+
+    assert str((123**25) ** Rational(1, 25)) == "123"
+    assert str((123**25 + 1)**Rational(1, 25)) != "123"
+    assert str((123**25 - 1)**Rational(1, 25)) != "123"
+    assert str((123**25 - 1)**Rational(1, 25)) != "122"
+
+    assert str(sqrt(Rational(81, 36))**3) == "27/8"
+    assert str(1/sqrt(Rational(81, 36))**3) == "8/27"
+
+    assert str(sqrt(-4)) == str(2*I)
+    assert str(2**Rational(1, 10**10)) == "2**(1/10000000000)"
+
+    assert sstr(Rational(2, 3), sympy_integers=True) == "S(2)/3"
+    x = Symbol("x")
+    assert sstr(x**Rational(2, 3), sympy_integers=True) == "x**(S(2)/3)"
+    assert sstr(Eq(x, Rational(2, 3)), sympy_integers=True) == "Eq(x, S(2)/3)"
+    assert sstr(Limit(x, x, Rational(7, 2)), sympy_integers=True) == \
+        "Limit(x, x, S(7)/2, dir='+')"
+
+
+def test_Float():
+    # NOTE dps is the whole number of decimal digits
+    assert str(Float('1.23', dps=1 + 2)) == '1.23'
+    assert str(Float('1.23456789', dps=1 + 8)) == '1.23456789'
+    assert str(
+        Float('1.234567890123456789', dps=1 + 18)) == '1.234567890123456789'
+    assert str(pi.evalf(1 + 2)) == '3.14'
+    assert str(pi.evalf(1 + 14)) == '3.14159265358979'
+    assert str(pi.evalf(1 + 64)) == ('3.141592653589793238462643383279'
+                                     '5028841971693993751058209749445923')
+    assert str(pi.round(-1)) == '0.0'
+    assert str((pi**400 - (pi**400).round(1)).n(2)) == '-0.e+88'
+    assert sstr(Float("100"), full_prec=False, min=-2, max=2) == '1.0e+2'
+    assert sstr(Float("100"), full_prec=False, min=-2, max=3) == '100.0'
+    assert sstr(Float("0.1"), full_prec=False, min=-2, max=3) == '0.1'
+    assert sstr(Float("0.099"), min=-2, max=3) == '9.90000000000000e-2'
+
+
+def test_Relational():
+    assert str(Rel(x, y, "<")) == "x < y"
+    assert str(Rel(x + y, y, "==")) == "Eq(x + y, y)"
+    assert str(Rel(x, y, "!=")) == "Ne(x, y)"
+    assert str(Eq(x, 1) | Eq(x, 2)) == "Eq(x, 1) | Eq(x, 2)"
+    assert str(Ne(x, 1) & Ne(x, 2)) == "Ne(x, 1) & Ne(x, 2)"
+
+
+def test_AppliedBinaryRelation():
+    assert str(Q.eq(x, y)) == "Q.eq(x, y)"
+    assert str(Q.ne(x, y)) == "Q.ne(x, y)"
+
+
+def test_CRootOf():
+    assert str(rootof(x**5 + 2*x - 1, 0)) == "CRootOf(x**5 + 2*x - 1, 0)"
+
+
+def test_RootSum():
+    f = x**5 + 2*x - 1
+
+    assert str(
+        RootSum(f, Lambda(z, z), auto=False)) == "RootSum(x**5 + 2*x - 1)"
+    assert str(RootSum(f, Lambda(
+        z, z**2), auto=False)) == "RootSum(x**5 + 2*x - 1, Lambda(z, z**2))"
+
+
+def test_GroebnerBasis():
+    assert str(groebner(
+        [], x, y)) == "GroebnerBasis([], x, y, domain='ZZ', order='lex')"
+
+    F = [x**2 - 3*y - x + 1, y**2 - 2*x + y - 1]
+
+    assert str(groebner(F, order='grlex')) == \
+        "GroebnerBasis([x**2 - x - 3*y + 1, y**2 - 2*x + y - 1], x, y, domain='ZZ', order='grlex')"
+    assert str(groebner(F, order='lex')) == \
+        "GroebnerBasis([2*x - y**2 - y + 1, y**4 + 2*y**3 - 3*y**2 - 16*y + 7], x, y, domain='ZZ', order='lex')"
+
+def test_set():
+    assert sstr(set()) == 'set()'
+    assert sstr(frozenset()) == 'frozenset()'
+
+    assert sstr({1}) == '{1}'
+    assert sstr(frozenset([1])) == 'frozenset({1})'
+    assert sstr({1, 2, 3}) == '{1, 2, 3}'
+    assert sstr(frozenset([1, 2, 3])) == 'frozenset({1, 2, 3})'
+
+    assert sstr(
+        {1, x, x**2, x**3, x**4}) == '{1, x, x**2, x**3, x**4}'
+    assert sstr(
+        frozenset([1, x, x**2, x**3, x**4])) == 'frozenset({1, x, x**2, x**3, x**4})'
+
+
+def test_SparseMatrix():
+    M = SparseMatrix([[x**+1, 1], [y, x + y]])
+    assert str(M) == "Matrix([[x, 1], [y, x + y]])"
+    assert sstr(M) == "Matrix([\n[x,     1],\n[y, x + y]])"
+
+
+def test_Sum():
+    assert str(summation(cos(3*z), (z, x, y))) == "Sum(cos(3*z), (z, x, y))"
+    assert str(Sum(x*y**2, (x, -2, 2), (y, -5, 5))) == \
+        "Sum(x*y**2, (x, -2, 2), (y, -5, 5))"
+
+
+def test_Symbol():
+    assert str(y) == "y"
+    assert str(x) == "x"
+    e = x
+    assert str(e) == "x"
+
+
+def test_tuple():
+    assert str((x,)) == sstr((x,)) == "(x,)"
+    assert str((x + y, 1 + x)) == sstr((x + y, 1 + x)) == "(x + y, x + 1)"
+    assert str((x + y, (
+        1 + x, x**2))) == sstr((x + y, (1 + x, x**2))) == "(x + y, (x + 1, x**2))"
+
+
+def test_Series_str():
+    tf1 = TransferFunction(x*y**2 - z, y**3 - t**3, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tf3 = TransferFunction(t*x**2 - t**w*x + w, t - y, y)
+    assert str(Series(tf1, tf2)) == \
+        "Series(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y))"
+    assert str(Series(tf1, tf2, tf3)) == \
+        "Series(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y), TransferFunction(t*x**2 - t**w*x + w, t - y, y))"
+    assert str(Series(-tf2, tf1)) == \
+        "Series(TransferFunction(-x + y, x + y, y), TransferFunction(x*y**2 - z, -t**3 + y**3, y))"
+
+
+def test_MIMOSeries_str():
+    tf1 = TransferFunction(x*y**2 - z, y**3 - t**3, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tfm_1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
+    tfm_2 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf2]])
+    assert str(MIMOSeries(tfm_1, tfm_2)) == \
+        "MIMOSeries(TransferFunctionMatrix(((TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y)), "\
+            "(TransferFunction(x - y, x + y, y), TransferFunction(x*y**2 - z, -t**3 + y**3, y)))), "\
+                "TransferFunctionMatrix(((TransferFunction(x - y, x + y, y), TransferFunction(x*y**2 - z, -t**3 + y**3, y)), "\
+                    "(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y)))))"
+
+
+def test_TransferFunction_str():
+    tf1 = TransferFunction(x - 1, x + 1, x)
+    assert str(tf1) == "TransferFunction(x - 1, x + 1, x)"
+    tf2 = TransferFunction(x + 1, 2 - y, x)
+    assert str(tf2) == "TransferFunction(x + 1, 2 - y, x)"
+    tf3 = TransferFunction(y, y**2 + 2*y + 3, y)
+    assert str(tf3) == "TransferFunction(y, y**2 + 2*y + 3, y)"
+
+
+def test_Parallel_str():
+    tf1 = TransferFunction(x*y**2 - z, y**3 - t**3, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tf3 = TransferFunction(t*x**2 - t**w*x + w, t - y, y)
+    assert str(Parallel(tf1, tf2)) == \
+        "Parallel(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y))"
+    assert str(Parallel(tf1, tf2, tf3)) == \
+        "Parallel(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y), TransferFunction(t*x**2 - t**w*x + w, t - y, y))"
+    assert str(Parallel(-tf2, tf1)) == \
+        "Parallel(TransferFunction(-x + y, x + y, y), TransferFunction(x*y**2 - z, -t**3 + y**3, y))"
+
+
+def test_MIMOParallel_str():
+    tf1 = TransferFunction(x*y**2 - z, y**3 - t**3, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tfm_1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
+    tfm_2 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf2]])
+    assert str(MIMOParallel(tfm_1, tfm_2)) == \
+        "MIMOParallel(TransferFunctionMatrix(((TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y)), "\
+            "(TransferFunction(x - y, x + y, y), TransferFunction(x*y**2 - z, -t**3 + y**3, y)))), "\
+                "TransferFunctionMatrix(((TransferFunction(x - y, x + y, y), TransferFunction(x*y**2 - z, -t**3 + y**3, y)), "\
+                    "(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y)))))"
+
+
+def test_Feedback_str():
+    tf1 = TransferFunction(x*y**2 - z, y**3 - t**3, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tf3 = TransferFunction(t*x**2 - t**w*x + w, t - y, y)
+    assert str(Feedback(tf1*tf2, tf3)) == \
+        "Feedback(Series(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y)), " \
+        "TransferFunction(t*x**2 - t**w*x + w, t - y, y), -1)"
+    assert str(Feedback(tf1, TransferFunction(1, 1, y), 1)) == \
+        "Feedback(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(1, 1, y), 1)"
+
+
+def test_MIMOFeedback_str():
+    tf1 = TransferFunction(x**2 - y**3, y - z, x)
+    tf2 = TransferFunction(y - x, z + y, x)
+    tfm_1 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf2]])
+    tfm_2 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
+    assert (str(MIMOFeedback(tfm_1, tfm_2)) \
+            == "MIMOFeedback(TransferFunctionMatrix(((TransferFunction(-x + y, y + z, x), TransferFunction(x**2 - y**3, y - z, x))," \
+            " (TransferFunction(x**2 - y**3, y - z, x), TransferFunction(-x + y, y + z, x)))), " \
+            "TransferFunctionMatrix(((TransferFunction(x**2 - y**3, y - z, x), " \
+            "TransferFunction(-x + y, y + z, x)), (TransferFunction(-x + y, y + z, x), TransferFunction(x**2 - y**3, y - z, x)))), -1)")
+    assert (str(MIMOFeedback(tfm_1, tfm_2, 1)) \
+            == "MIMOFeedback(TransferFunctionMatrix(((TransferFunction(-x + y, y + z, x), TransferFunction(x**2 - y**3, y - z, x)), " \
+            "(TransferFunction(x**2 - y**3, y - z, x), TransferFunction(-x + y, y + z, x)))), " \
+            "TransferFunctionMatrix(((TransferFunction(x**2 - y**3, y - z, x), TransferFunction(-x + y, y + z, x)), "\
+            "(TransferFunction(-x + y, y + z, x), TransferFunction(x**2 - y**3, y - z, x)))), 1)")
+
+
+def test_TransferFunctionMatrix_str():
+    tf1 = TransferFunction(x*y**2 - z, y**3 - t**3, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tf3 = TransferFunction(t*x**2 - t**w*x + w, t - y, y)
+    assert str(TransferFunctionMatrix([[tf1], [tf2]])) == \
+        "TransferFunctionMatrix(((TransferFunction(x*y**2 - z, -t**3 + y**3, y),), (TransferFunction(x - y, x + y, y),)))"
+    assert str(TransferFunctionMatrix([[tf1, tf2], [tf3, tf2]])) == \
+        "TransferFunctionMatrix(((TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y)), (TransferFunction(t*x**2 - t**w*x + w, t - y, y), TransferFunction(x - y, x + y, y))))"
+
+
+def test_Quaternion_str_printer():
+    q = Quaternion(x, y, z, t)
+    assert str(q) == "x + y*i + z*j + t*k"
+    q = Quaternion(x,y,z,x*t)
+    assert str(q) == "x + y*i + z*j + t*x*k"
+    q = Quaternion(x,y,z,x+t)
+    assert str(q) == "x + y*i + z*j + (t + x)*k"
+
+
+def test_Quantity_str():
+    assert sstr(second, abbrev=True) == "s"
+    assert sstr(joule, abbrev=True) == "J"
+    assert str(second) == "second"
+    assert str(joule) == "joule"
+
+
+def test_wild_str():
+    # Check expressions containing Wild not causing infinite recursion
+    w = Wild('x')
+    assert str(w + 1) == 'x_ + 1'
+    assert str(exp(2**w) + 5) == 'exp(2**x_) + 5'
+    assert str(3*w + 1) == '3*x_ + 1'
+    assert str(1/w + 1) == '1 + 1/x_'
+    assert str(w**2 + 1) == 'x_**2 + 1'
+    assert str(1/(1 - w)) == '1/(1 - x_)'
+
+
+def test_wild_matchpy():
+    from sympy.utilities.matchpy_connector import WildDot, WildPlus, WildStar
+
+    matchpy = import_module("matchpy")
+
+    if matchpy is None:
+        return
+
+    wd = WildDot('w_')
+    wp = WildPlus('w__')
+    ws = WildStar('w___')
+
+    assert str(wd) == 'w_'
+    assert str(wp) == 'w__'
+    assert str(ws) == 'w___'
+
+    assert str(wp/ws + 2**wd) == '2**w_ + w__/w___'
+    assert str(sin(wd)*cos(wp)*sqrt(ws)) == 'sqrt(w___)*sin(w_)*cos(w__)'
+
+
+def test_zeta():
+    assert str(zeta(3)) == "zeta(3)"
+
+
+def test_issue_3101():
+    e = x - y
+    a = str(e)
+    b = str(e)
+    assert a == b
+
+
+def test_issue_3103():
+    e = -2*sqrt(x) - y/sqrt(x)/2
+    assert str(e) not in ["(-2)*x**1/2(-1/2)*x**(-1/2)*y",
+            "-2*x**1/2(-1/2)*x**(-1/2)*y", "-2*x**1/2-1/2*x**-1/2*w"]
+    assert str(e) == "-2*sqrt(x) - y/(2*sqrt(x))"
+
+
+def test_issue_4021():
+    e = Integral(x, x) + 1
+    assert str(e) == 'Integral(x, x) + 1'
+
+
+def test_sstrrepr():
+    assert sstr('abc') == 'abc'
+    assert sstrrepr('abc') == "'abc'"
+
+    e = ['a', 'b', 'c', x]
+    assert sstr(e) == "[a, b, c, x]"
+    assert sstrrepr(e) == "['a', 'b', 'c', x]"
+
+
+def test_infinity():
+    assert sstr(oo*I) == "oo*I"
+
+
+def test_full_prec():
+    assert sstr(S("0.3"), full_prec=True) == "0.300000000000000"
+    assert sstr(S("0.3"), full_prec="auto") == "0.300000000000000"
+    assert sstr(S("0.3"), full_prec=False) == "0.3"
+    assert sstr(S("0.3")*x, full_prec=True) in [
+        "0.300000000000000*x",
+        "x*0.300000000000000"
+    ]
+    assert sstr(S("0.3")*x, full_prec="auto") in [
+        "0.3*x",
+        "x*0.3"
+    ]
+    assert sstr(S("0.3")*x, full_prec=False) in [
+        "0.3*x",
+        "x*0.3"
+    ]
+
+
+def test_noncommutative():
+    A, B, C = symbols('A,B,C', commutative=False)
+
+    assert sstr(A*B*C**-1) == "A*B*C**(-1)"
+    assert sstr(C**-1*A*B) == "C**(-1)*A*B"
+    assert sstr(A*C**-1*B) == "A*C**(-1)*B"
+    assert sstr(sqrt(A)) == "sqrt(A)"
+    assert sstr(1/sqrt(A)) == "A**(-1/2)"
+
+
+def test_empty_printer():
+    str_printer = StrPrinter()
+    assert str_printer.emptyPrinter("foo") == "foo"
+    assert str_printer.emptyPrinter(x*y) == "x*y"
+    assert str_printer.emptyPrinter(32) == "32"
+
+
+def test_settings():
+    raises(TypeError, lambda: sstr(S(4), method="garbage"))
+
+
+def test_RandomDomain():
+    from sympy.stats import Normal, Die, Exponential, pspace, where
+    X = Normal('x1', 0, 1)
+    assert str(where(X > 0)) == "Domain: (0 < x1) & (x1 < oo)"
+
+    D = Die('d1', 6)
+    assert str(where(D > 4)) == "Domain: Eq(d1, 5) | Eq(d1, 6)"
+
+    A = Exponential('a', 1)
+    B = Exponential('b', 1)
+    assert str(pspace(Tuple(A, B)).domain) == "Domain: (0 <= a) & (0 <= b) & (a < oo) & (b < oo)"
+
+
+def test_FiniteSet():
+    assert str(FiniteSet(*range(1, 51))) == (
+        '{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,'
+        ' 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,'
+        ' 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50}'
+    )
+    assert str(FiniteSet(*range(1, 6))) == '{1, 2, 3, 4, 5}'
+    assert str(FiniteSet(*[x*y, x**2])) == '{x**2, x*y}'
+    assert str(FiniteSet(FiniteSet(FiniteSet(x, y), 5), FiniteSet(x,y), 5)
+               ) == 'FiniteSet(5, FiniteSet(5, {x, y}), {x, y})'
+
+
+def test_Partition():
+    assert str(Partition(FiniteSet(x, y), {z})) == 'Partition({z}, {x, y})'
+
+def test_UniversalSet():
+    assert str(S.UniversalSet) == 'UniversalSet'
+
+
+def test_PrettyPoly():
+    F = QQ.frac_field(x, y)
+    R = QQ[x, y]
+    assert sstr(F.convert(x/(x + y))) == sstr(x/(x + y))
+    assert sstr(R.convert(x + y)) == sstr(x + y)
+
+
+def test_categories():
+    from sympy.categories import (Object, NamedMorphism,
+        IdentityMorphism, Category)
+
+    A = Object("A")
+    B = Object("B")
+
+    f = NamedMorphism(A, B, "f")
+    id_A = IdentityMorphism(A)
+
+    K = Category("K")
+
+    assert str(A) == 'Object("A")'
+    assert str(f) == 'NamedMorphism(Object("A"), Object("B"), "f")'
+    assert str(id_A) == 'IdentityMorphism(Object("A"))'
+
+    assert str(K) == 'Category("K")'
+
+
+def test_Tr():
+    A, B = symbols('A B', commutative=False)
+    t = Tr(A*B)
+    assert str(t) == 'Tr(A*B)'
+
+
+def test_issue_6387():
+    assert str(factor(-3.0*z + 3)) == '-3.0*(1.0*z - 1.0)'
+
+
+def test_MatMul_MatAdd():
+    X, Y = MatrixSymbol("X", 2, 2), MatrixSymbol("Y", 2, 2)
+    assert str(2*(X + Y)) == "2*X + 2*Y"
+
+    assert str(I*X) == "I*X"
+    assert str(-I*X) == "-I*X"
+    assert str((1 + I)*X) == '(1 + I)*X'
+    assert str(-(1 + I)*X) == '(-1 - I)*X'
+    assert str(MatAdd(MatAdd(X, Y), MatAdd(X, Y))) == '(X + Y) + (X + Y)'
+
+
+def test_MatrixSlice():
+    n = Symbol('n', integer=True)
+    X = MatrixSymbol('X', n, n)
+    Y = MatrixSymbol('Y', 10, 10)
+    Z = MatrixSymbol('Z', 10, 10)
+
+    assert str(MatrixSlice(X, (None, None, None), (None, None, None))) == 'X[:, :]'
+    assert str(X[x:x + 1, y:y + 1]) == 'X[x:x + 1, y:y + 1]'
+    assert str(X[x:x + 1:2, y:y + 1:2]) == 'X[x:x + 1:2, y:y + 1:2]'
+    assert str(X[:x, y:]) == 'X[:x, y:]'
+    assert str(X[:x, y:]) == 'X[:x, y:]'
+    assert str(X[x:, :y]) == 'X[x:, :y]'
+    assert str(X[x:y, z:w]) == 'X[x:y, z:w]'
+    assert str(X[x:y:t, w:t:x]) == 'X[x:y:t, w:t:x]'
+    assert str(X[x::y, t::w]) == 'X[x::y, t::w]'
+    assert str(X[:x:y, :t:w]) == 'X[:x:y, :t:w]'
+    assert str(X[::x, ::y]) == 'X[::x, ::y]'
+    assert str(MatrixSlice(X, (0, None, None), (0, None, None))) == 'X[:, :]'
+    assert str(MatrixSlice(X, (None, n, None), (None, n, None))) == 'X[:, :]'
+    assert str(MatrixSlice(X, (0, n, None), (0, n, None))) == 'X[:, :]'
+    assert str(MatrixSlice(X, (0, n, 2), (0, n, 2))) == 'X[::2, ::2]'
+    assert str(X[1:2:3, 4:5:6]) == 'X[1:2:3, 4:5:6]'
+    assert str(X[1:3:5, 4:6:8]) == 'X[1:3:5, 4:6:8]'
+    assert str(X[1:10:2]) == 'X[1:10:2, :]'
+    assert str(Y[:5, 1:9:2]) == 'Y[:5, 1:9:2]'
+    assert str(Y[:5, 1:10:2]) == 'Y[:5, 1::2]'
+    assert str(Y[5, :5:2]) == 'Y[5:6, :5:2]'
+    assert str(X[0:1, 0:1]) == 'X[:1, :1]'
+    assert str(X[0:1:2, 0:1:2]) == 'X[:1:2, :1:2]'
+    assert str((Y + Z)[2:, 2:]) == '(Y + Z)[2:, 2:]'
+
+def test_true_false():
+    assert str(true) == repr(true) == sstr(true) == "True"
+    assert str(false) == repr(false) == sstr(false) == "False"
+
+def test_Equivalent():
+    assert str(Equivalent(y, x)) == "Equivalent(x, y)"
+
+def test_Xor():
+    assert str(Xor(y, x, evaluate=False)) == "x ^ y"
+
+def test_Complement():
+    assert str(Complement(S.Reals, S.Naturals)) == 'Complement(Reals, Naturals)'
+
+def test_SymmetricDifference():
+    assert str(SymmetricDifference(Interval(2, 3), Interval(3, 4),evaluate=False)) == \
+           'SymmetricDifference(Interval(2, 3), Interval(3, 4))'
+
+
+def test_UnevaluatedExpr():
+    a, b = symbols("a b")
+    expr1 = 2*UnevaluatedExpr(a+b)
+    assert str(expr1) == "2*(a + b)"
+
+
+def test_MatrixElement_printing():
+    # test cases for issue #11821
+    A = MatrixSymbol("A", 1, 3)
+    B = MatrixSymbol("B", 1, 3)
+    C = MatrixSymbol("C", 1, 3)
+
+    assert(str(A[0, 0]) == "A[0, 0]")
+    assert(str(3 * A[0, 0]) == "3*A[0, 0]")
+
+    F = C[0, 0].subs(C, A - B)
+    assert str(F) == "(A - B)[0, 0]"
+
+
+def test_MatrixSymbol_printing():
+    A = MatrixSymbol("A", 3, 3)
+    B = MatrixSymbol("B", 3, 3)
+
+    assert str(A - A*B - B) == "A - A*B - B"
+    assert str(A*B - (A+B)) == "-A + A*B - B"
+    assert str(A**(-1)) == "A**(-1)"
+    assert str(A**3) == "A**3"
+
+
+def test_MatrixExpressions():
+    n = Symbol('n', integer=True)
+    X = MatrixSymbol('X', n, n)
+
+    assert str(X) == "X"
+
+    # Apply function elementwise (`ElementwiseApplyFunc`):
+
+    expr = (X.T*X).applyfunc(sin)
+    assert str(expr) == 'Lambda(_d, sin(_d)).(X.T*X)'
+
+    lamda = Lambda(x, 1/x)
+    expr = (n*X).applyfunc(lamda)
+    assert str(expr) == 'Lambda(x, 1/x).(n*X)'
+
+
+def test_Subs_printing():
+    assert str(Subs(x, (x,), (1,))) == 'Subs(x, x, 1)'
+    assert str(Subs(x + y, (x, y), (1, 2))) == 'Subs(x + y, (x, y), (1, 2))'
+
+
+def test_issue_15716():
+    e = Integral(factorial(x), (x, -oo, oo))
+    assert e.as_terms() == ([(e, ((1.0, 0.0), (1,), ()))], [e])
+
+
+def test_str_special_matrices():
+    from sympy.matrices import Identity, ZeroMatrix, OneMatrix
+    assert str(Identity(4)) == 'I'
+    assert str(ZeroMatrix(2, 2)) == '0'
+    assert str(OneMatrix(2, 2)) == '1'
+
+
+def test_issue_14567():
+    assert factorial(Sum(-1, (x, 0, 0))) + y  # doesn't raise an error
+
+
+def test_issue_21823():
+    assert str(Partition([1, 2])) == 'Partition({1, 2})'
+    assert str(Partition({1, 2})) == 'Partition({1, 2})'
+
+
+def test_issue_22689():
+    assert str(Mul(Pow(x,-2, evaluate=False), Pow(3,-1,evaluate=False), evaluate=False)) == "1/(x**2*3)"
+
+
+def test_issue_21119_21460():
+    ss = lambda x: str(S(x, evaluate=False))
+    assert ss('4/2') == '4/2'
+    assert ss('4/-2') == '4/(-2)'
+    assert ss('-4/2') == '-4/2'
+    assert ss('-4/-2') == '-4/(-2)'
+    assert ss('-2*3/-1') == '-2*3/(-1)'
+    assert ss('-2*3/-1/2') == '-2*3/(-1*2)'
+    assert ss('4/2/1') == '4/(2*1)'
+    assert ss('-2/-1/2') == '-2/(-1*2)'
+    assert ss('2*3*4**(-2*3)') == '2*3/4**(2*3)'
+    assert ss('2*3*1*4**(-2*3)') == '2*3*1/4**(2*3)'
+
+
+def test_Str():
+    from sympy.core.symbol import Str
+    assert str(Str('x')) == 'x'
+    assert sstrrepr(Str('x')) == "Str('x')"
+
+
+def test_diffgeom():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, BaseScalarField
+    x,y = symbols('x y', real=True)
+    m = Manifold('M', 2)
+    assert str(m) == "M"
+    p = Patch('P', m)
+    assert str(p) == "P"
+    rect = CoordSystem('rect', p, [x, y])
+    assert str(rect) == "rect"
+    b = BaseScalarField(rect, 0)
+    assert str(b) == "x"
+
+def test_NDimArray():
+    assert sstr(NDimArray(1.0), full_prec=True) == '1.00000000000000'
+    assert sstr(NDimArray(1.0), full_prec=False) == '1.0'
+    assert sstr(NDimArray([1.0, 2.0]), full_prec=True) == '[1.00000000000000, 2.00000000000000]'
+    assert sstr(NDimArray([1.0, 2.0]), full_prec=False) == '[1.0, 2.0]'
+
+def test_Predicate():
+    assert sstr(Q.even) == 'Q.even'
+
+def test_AppliedPredicate():
+    assert sstr(Q.even(x)) == 'Q.even(x)'
+
+def test_printing_str_array_expressions():
+    assert sstr(ArraySymbol("A", (2, 3, 4))) == "A"
+    assert sstr(ArrayElement("A", (2, 1/(1-x), 0))) == "A[2, 1/(1 - x), 0]"
+    M = MatrixSymbol("M", 3, 3)
+    N = MatrixSymbol("N", 3, 3)
+    assert sstr(ArrayElement(M*N, [x, 0])) == "(M*N)[x, 0]"
+
+def test_printing_stats():
+    # issue 24132
+    x = RandomSymbol("x")
+    y = RandomSymbol("y")
+    z1 = Probability(x > 0)*Identity(2)
+    z2 = Expectation(x)*Identity(2)
+    z3 = Variance(x)*Identity(2)
+    z4 = Covariance(x, y) * Identity(2)
+
+    assert str(z1) == "Probability(x > 0)*I"
+    assert str(z2) == "Expectation(x)*I"
+    assert str(z3) == "Variance(x)*I"
+    assert str(z4) ==  "Covariance(x, y)*I"
+    assert z1.is_commutative == False
+    assert z2.is_commutative == False
+    assert z3.is_commutative == False
+    assert z4.is_commutative == False
+    assert z2._eval_is_commutative() == False
+    assert z3._eval_is_commutative() == False
+    assert z4._eval_is_commutative() == False

lib/python3.12/site-packages/sympy/printing/tests/test_tree.py

@@ -0,0 +1,196 @@
+from sympy.printing.tree import tree
+from sympy.testing.pytest import XFAIL
+
+
+# Remove this flag after making _assumptions cache deterministic.
+@XFAIL
+def test_print_tree_MatAdd():
+    from sympy.matrices.expressions import MatrixSymbol
+    A = MatrixSymbol('A', 3, 3)
+    B = MatrixSymbol('B', 3, 3)
+
+    test_str = [
+        'MatAdd: A + B\n',
+        'algebraic: False\n',
+        'commutative: False\n',
+        'complex: False\n',
+        'composite: False\n',
+        'even: False\n',
+        'extended_negative: False\n',
+        'extended_nonnegative: False\n',
+        'extended_nonpositive: False\n',
+        'extended_nonzero: False\n',
+        'extended_positive: False\n',
+        'extended_real: False\n',
+        'imaginary: False\n',
+        'integer: False\n',
+        'irrational: False\n',
+        'negative: False\n',
+        'noninteger: False\n',
+        'nonnegative: False\n',
+        'nonpositive: False\n',
+        'nonzero: False\n',
+        'odd: False\n',
+        'positive: False\n',
+        'prime: False\n',
+        'rational: False\n',
+        'real: False\n',
+        'transcendental: False\n',
+        'zero: False\n',
+        '+-MatrixSymbol: A\n',
+        '| algebraic: False\n',
+        '| commutative: False\n',
+        '| complex: False\n',
+        '| composite: False\n',
+        '| even: False\n',
+        '| extended_negative: False\n',
+        '| extended_nonnegative: False\n',
+        '| extended_nonpositive: False\n',
+        '| extended_nonzero: False\n',
+        '| extended_positive: False\n',
+        '| extended_real: False\n',
+        '| imaginary: False\n',
+        '| integer: False\n',
+        '| irrational: False\n',
+        '| negative: False\n',
+        '| noninteger: False\n',
+        '| nonnegative: False\n',
+        '| nonpositive: False\n',
+        '| nonzero: False\n',
+        '| odd: False\n',
+        '| positive: False\n',
+        '| prime: False\n',
+        '| rational: False\n',
+        '| real: False\n',
+        '| transcendental: False\n',
+        '| zero: False\n',
+        '| +-Symbol: A\n',
+        '| | commutative: True\n',
+        '| +-Integer: 3\n',
+        '| | algebraic: True\n',
+        '| | commutative: True\n',
+        '| | complex: True\n',
+        '| | extended_negative: False\n',
+        '| | extended_nonnegative: True\n',
+        '| | extended_real: True\n',
+        '| | finite: True\n',
+        '| | hermitian: True\n',
+        '| | imaginary: False\n',
+        '| | infinite: False\n',
+        '| | integer: True\n',
+        '| | irrational: False\n',
+        '| | negative: False\n',
+        '| | noninteger: False\n',
+        '| | nonnegative: True\n',
+        '| | rational: True\n',
+        '| | real: True\n',
+        '| | transcendental: False\n',
+        '| +-Integer: 3\n',
+        '|   algebraic: True\n',
+        '|   commutative: True\n',
+        '|   complex: True\n',
+        '|   extended_negative: False\n',
+        '|   extended_nonnegative: True\n',
+        '|   extended_real: True\n',
+        '|   finite: True\n',
+        '|   hermitian: True\n',
+        '|   imaginary: False\n',
+        '|   infinite: False\n',
+        '|   integer: True\n',
+        '|   irrational: False\n',
+        '|   negative: False\n',
+        '|   noninteger: False\n',
+        '|   nonnegative: True\n',
+        '|   rational: True\n',
+        '|   real: True\n',
+        '|   transcendental: False\n',
+        '+-MatrixSymbol: B\n',
+        '  algebraic: False\n',
+        '  commutative: False\n',
+        '  complex: False\n',
+        '  composite: False\n',
+        '  even: False\n',
+        '  extended_negative: False\n',
+        '  extended_nonnegative: False\n',
+        '  extended_nonpositive: False\n',
+        '  extended_nonzero: False\n',
+        '  extended_positive: False\n',
+        '  extended_real: False\n',
+        '  imaginary: False\n',
+        '  integer: False\n',
+        '  irrational: False\n',
+        '  negative: False\n',
+        '  noninteger: False\n',
+        '  nonnegative: False\n',
+        '  nonpositive: False\n',
+        '  nonzero: False\n',
+        '  odd: False\n',
+        '  positive: False\n',
+        '  prime: False\n',
+        '  rational: False\n',
+        '  real: False\n',
+        '  transcendental: False\n',
+        '  zero: False\n',
+        '  +-Symbol: B\n',
+        '  | commutative: True\n',
+        '  +-Integer: 3\n',
+        '  | algebraic: True\n',
+        '  | commutative: True\n',
+        '  | complex: True\n',
+        '  | extended_negative: False\n',
+        '  | extended_nonnegative: True\n',
+        '  | extended_real: True\n',
+        '  | finite: True\n',
+        '  | hermitian: True\n',
+        '  | imaginary: False\n',
+        '  | infinite: False\n',
+        '  | integer: True\n',
+        '  | irrational: False\n',
+        '  | negative: False\n',
+        '  | noninteger: False\n',
+        '  | nonnegative: True\n',
+        '  | rational: True\n',
+        '  | real: True\n',
+        '  | transcendental: False\n',
+        '  +-Integer: 3\n',
+        '    algebraic: True\n',
+        '    commutative: True\n',
+        '    complex: True\n',
+        '    extended_negative: False\n',
+        '    extended_nonnegative: True\n',
+        '    extended_real: True\n',
+        '    finite: True\n',
+        '    hermitian: True\n',
+        '    imaginary: False\n',
+        '    infinite: False\n',
+        '    integer: True\n',
+        '    irrational: False\n',
+        '    negative: False\n',
+        '    noninteger: False\n',
+        '    nonnegative: True\n',
+        '    rational: True\n',
+        '    real: True\n',
+        '    transcendental: False\n'
+    ]
+
+    assert tree(A + B) == "".join(test_str)
+
+
+def test_print_tree_MatAdd_noassumptions():
+    from sympy.matrices.expressions import MatrixSymbol
+    A = MatrixSymbol('A', 3, 3)
+    B = MatrixSymbol('B', 3, 3)
+
+    test_str = \
+"""MatAdd: A + B
++-MatrixSymbol: A
+| +-Str: A
+| +-Integer: 3
+| +-Integer: 3
++-MatrixSymbol: B
+  +-Str: B
+  +-Integer: 3
+  +-Integer: 3
+"""
+
+    assert tree(A + B, assumptions=False) == test_str