Add files using upload-large-folder tool

ckpts/universal/global_step80/zero/13.mlp.dense_h_to_4h_swiglu.weight/exp_avg_sq.pt

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

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

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

ckpts/universal/global_step80/zero/19.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt

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

ckpts/universal/global_step80/zero/19.mlp.dense_h_to_4h_swiglu.weight/fp32.pt

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

ckpts/universal/global_step80/zero/22.attention.dense.weight/exp_avg_sq.pt

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

ckpts/universal/global_step80/zero/22.attention.dense.weight/fp32.pt

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

venv/lib/python3.10/site-packages/sympy/plotting/intervalmath/__init__.py

@@ -0,0 +1,12 @@
+from .interval_arithmetic import interval
+from .lib_interval import (Abs, exp, log, log10, sin, cos, tan, sqrt,
+                          imin, imax, sinh, cosh, tanh, acosh, asinh, atanh,
+                          asin, acos, atan, ceil, floor, And, Or)
+
+__all__ = [
+    'interval',
+
+    'Abs', 'exp', 'log', 'log10', 'sin', 'cos', 'tan', 'sqrt', 'imin', 'imax',
+    'sinh', 'cosh', 'tanh', 'acosh', 'asinh', 'atanh', 'asin', 'acos', 'atan',
+    'ceil', 'floor', 'And', 'Or',
+]

venv/lib/python3.10/site-packages/sympy/plotting/intervalmath/interval_arithmetic.py

@@ -0,0 +1,412 @@
+"""
+Interval Arithmetic for plotting.
+This module does not implement interval arithmetic accurately and
+hence cannot be used for purposes other than plotting. If you want
+to use interval arithmetic, use mpmath's interval arithmetic.
+
+The module implements interval arithmetic using numpy and
+python floating points. The rounding up and down is not handled
+and hence this is not an accurate implementation of interval
+arithmetic.
+
+The module uses numpy for speed which cannot be achieved with mpmath.
+"""
+
+# Q: Why use numpy? Why not simply use mpmath's interval arithmetic?
+# A: mpmath's interval arithmetic simulates a floating point unit
+# and hence is slow, while numpy evaluations are orders of magnitude
+# faster.
+
+# Q: Why create a separate class for intervals? Why not use SymPy's
+# Interval Sets?
+# A: The functionalities that will be required for plotting is quite
+# different from what Interval Sets implement.
+
+# Q: Why is rounding up and down according to IEEE754 not handled?
+# A: It is not possible to do it in both numpy and python. An external
+# library has to used, which defeats the whole purpose i.e., speed. Also
+# rounding is handled for very few functions in those libraries.
+
+# Q Will my plots be affected?
+# A It will not affect most of the plots. The interval arithmetic
+# module based suffers the same problems as that of floating point
+# arithmetic.
+
+from sympy.core.logic import fuzzy_and
+from sympy.simplify.simplify import nsimplify
+
+from .interval_membership import intervalMembership
+
+
+class interval:
+    """ Represents an interval containing floating points as start and
+    end of the interval
+    The is_valid variable tracks whether the interval obtained as the
+    result of the function is in the domain and is continuous.
+    - True: Represents the interval result of a function is continuous and
+            in the domain of the function.
+    - False: The interval argument of the function was not in the domain of
+             the function, hence the is_valid of the result interval is False
+    - None: The function was not continuous over the interval or
+            the function's argument interval is partly in the domain of the
+            function
+
+    A comparison between an interval and a real number, or a
+    comparison between two intervals may return ``intervalMembership``
+    of two 3-valued logic values.
+    """
+
+    def __init__(self, *args, is_valid=True, **kwargs):
+        self.is_valid = is_valid
+        if len(args) == 1:
+            if isinstance(args[0], interval):
+                self.start, self.end = args[0].start, args[0].end
+            else:
+                self.start = float(args[0])
+                self.end = float(args[0])
+        elif len(args) == 2:
+            if args[0] < args[1]:
+                self.start = float(args[0])
+                self.end = float(args[1])
+            else:
+                self.start = float(args[1])
+                self.end = float(args[0])
+
+        else:
+            raise ValueError("interval takes a maximum of two float values "
+                            "as arguments")
+
+    @property
+    def mid(self):
+        return (self.start + self.end) / 2.0
+
+    @property
+    def width(self):
+        return self.end - self.start
+
+    def __repr__(self):
+        return "interval(%f, %f)" % (self.start, self.end)
+
+    def __str__(self):
+        return "[%f, %f]" % (self.start, self.end)
+
+    def __lt__(self, other):
+        if isinstance(other, (int, float)):
+            if self.end < other:
+                return intervalMembership(True, self.is_valid)
+            elif self.start > other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+
+        elif isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.end < other. start:
+                return intervalMembership(True, valid)
+            if self.start > other.end:
+                return intervalMembership(False, valid)
+            return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __gt__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start > other:
+                return intervalMembership(True, self.is_valid)
+            elif self.end < other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+        elif isinstance(other, interval):
+            return other.__lt__(self)
+        else:
+            return NotImplemented
+
+    def __eq__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start == other and self.end == other:
+                return intervalMembership(True, self.is_valid)
+            if other in self:
+                return intervalMembership(None, self.is_valid)
+            else:
+                return intervalMembership(False, self.is_valid)
+
+        if isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.start == other.start and self.end == other.end:
+                return intervalMembership(True, valid)
+            elif self.__lt__(other)[0] is not None:
+                return intervalMembership(False, valid)
+            else:
+                return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __ne__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start == other and self.end == other:
+                return intervalMembership(False, self.is_valid)
+            if other in self:
+                return intervalMembership(None, self.is_valid)
+            else:
+                return intervalMembership(True, self.is_valid)
+
+        if isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.start == other.start and self.end == other.end:
+                return intervalMembership(False, valid)
+            if not self.__lt__(other)[0] is None:
+                return intervalMembership(True, valid)
+            return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __le__(self, other):
+        if isinstance(other, (int, float)):
+            if self.end <= other:
+                return intervalMembership(True, self.is_valid)
+            if self.start > other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+
+        if isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.end <= other.start:
+                return intervalMembership(True, valid)
+            if self.start > other.end:
+                return intervalMembership(False, valid)
+            return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __ge__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start >= other:
+                return intervalMembership(True, self.is_valid)
+            elif self.end < other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+        elif isinstance(other, interval):
+            return other.__le__(self)
+
+    def __add__(self, other):
+        if isinstance(other, (int, float)):
+            if self.is_valid:
+                return interval(self.start + other, self.end + other)
+            else:
+                start = self.start + other
+                end = self.end + other
+                return interval(start, end, is_valid=self.is_valid)
+
+        elif isinstance(other, interval):
+            start = self.start + other.start
+            end = self.end + other.end
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            return interval(start, end, is_valid=valid)
+        else:
+            return NotImplemented
+
+    __radd__ = __add__
+
+    def __sub__(self, other):
+        if isinstance(other, (int, float)):
+            start = self.start - other
+            end = self.end - other
+            return interval(start, end, is_valid=self.is_valid)
+
+        elif isinstance(other, interval):
+            start = self.start - other.end
+            end = self.end - other.start
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            return interval(start, end, is_valid=valid)
+        else:
+            return NotImplemented
+
+    def __rsub__(self, other):
+        if isinstance(other, (int, float)):
+            start = other - self.end
+            end = other - self.start
+            return interval(start, end, is_valid=self.is_valid)
+        elif isinstance(other, interval):
+            return other.__sub__(self)
+        else:
+            return NotImplemented
+
+    def __neg__(self):
+        if self.is_valid:
+            return interval(-self.end, -self.start)
+        else:
+            return interval(-self.end, -self.start, is_valid=self.is_valid)
+
+    def __mul__(self, other):
+        if isinstance(other, interval):
+            if self.is_valid is False or other.is_valid is False:
+                return interval(-float('inf'), float('inf'), is_valid=False)
+            elif self.is_valid is None or other.is_valid is None:
+                return interval(-float('inf'), float('inf'), is_valid=None)
+            else:
+                inters = []
+                inters.append(self.start * other.start)
+                inters.append(self.end * other.start)
+                inters.append(self.start * other.end)
+                inters.append(self.end * other.end)
+                start = min(inters)
+                end = max(inters)
+                return interval(start, end)
+        elif isinstance(other, (int, float)):
+            return interval(self.start*other, self.end*other, is_valid=self.is_valid)
+        else:
+            return NotImplemented
+
+    __rmul__ = __mul__
+
+    def __contains__(self, other):
+        if isinstance(other, (int, float)):
+            return self.start <= other and self.end >= other
+        else:
+            return self.start <= other.start and other.end <= self.end
+
+    def __rtruediv__(self, other):
+        if isinstance(other, (int, float)):
+            other = interval(other)
+            return other.__truediv__(self)
+        elif isinstance(other, interval):
+            return other.__truediv__(self)
+        else:
+            return NotImplemented
+
+    def __truediv__(self, other):
+        # Both None and False are handled
+        if not self.is_valid:
+            # Don't divide as the value is not valid
+            return interval(-float('inf'), float('inf'), is_valid=self.is_valid)
+        if isinstance(other, (int, float)):
+            if other == 0:
+                # Divide by zero encountered. valid nowhere
+                return interval(-float('inf'), float('inf'), is_valid=False)
+            else:
+                return interval(self.start / other, self.end / other)
+
+        elif isinstance(other, interval):
+            if other.is_valid is False or self.is_valid is False:
+                return interval(-float('inf'), float('inf'), is_valid=False)
+            elif other.is_valid is None or self.is_valid is None:
+                return interval(-float('inf'), float('inf'), is_valid=None)
+            else:
+               # denominator contains both signs, i.e. being divided by zero
+               # return the whole real line with is_valid = None
+                if 0 in other:
+                    return interval(-float('inf'), float('inf'), is_valid=None)
+
+                # denominator negative
+                this = self
+                if other.end < 0:
+                    this = -this
+                    other = -other
+
+                # denominator positive
+                inters = []
+                inters.append(this.start / other.start)
+                inters.append(this.end / other.start)
+                inters.append(this.start / other.end)
+                inters.append(this.end / other.end)
+                start = max(inters)
+                end = min(inters)
+                return interval(start, end)
+        else:
+            return NotImplemented
+
+    def __pow__(self, other):
+        # Implements only power to an integer.
+        from .lib_interval import exp, log
+        if not self.is_valid:
+            return self
+        if isinstance(other, interval):
+            return exp(other * log(self))
+        elif isinstance(other, (float, int)):
+            if other < 0:
+                return 1 / self.__pow__(abs(other))
+            else:
+                if int(other) == other:
+                    return _pow_int(self, other)
+                else:
+                    return _pow_float(self, other)
+        else:
+            return NotImplemented
+
+    def __rpow__(self, other):
+        if isinstance(other, (float, int)):
+            if not self.is_valid:
+                #Don't do anything
+                return self
+            elif other < 0:
+                if self.width > 0:
+                    return interval(-float('inf'), float('inf'), is_valid=False)
+                else:
+                    power_rational = nsimplify(self.start)
+                    num, denom = power_rational.as_numer_denom()
+                    if denom % 2 == 0:
+                        return interval(-float('inf'), float('inf'),
+                                        is_valid=False)
+                    else:
+                        start = -abs(other)**self.start
+                        end = start
+                        return interval(start, end)
+            else:
+                return interval(other**self.start, other**self.end)
+        elif isinstance(other, interval):
+            return other.__pow__(self)
+        else:
+            return NotImplemented
+
+    def __hash__(self):
+        return hash((self.is_valid, self.start, self.end))
+
+
+def _pow_float(inter, power):
+    """Evaluates an interval raised to a floating point."""
+    power_rational = nsimplify(power)
+    num, denom = power_rational.as_numer_denom()
+    if num % 2 == 0:
+        start = abs(inter.start)**power
+        end = abs(inter.end)**power
+        if start < 0:
+            ret = interval(0, max(start, end))
+        else:
+            ret = interval(start, end)
+        return ret
+    elif denom % 2 == 0:
+        if inter.end < 0:
+            return interval(-float('inf'), float('inf'), is_valid=False)
+        elif inter.start < 0:
+            return interval(0, inter.end**power, is_valid=None)
+        else:
+            return interval(inter.start**power, inter.end**power)
+    else:
+        if inter.start < 0:
+            start = -abs(inter.start)**power
+        else:
+            start = inter.start**power
+
+        if inter.end < 0:
+            end = -abs(inter.end)**power
+        else:
+            end = inter.end**power
+
+        return interval(start, end, is_valid=inter.is_valid)
+
+
+def _pow_int(inter, power):
+    """Evaluates an interval raised to an integer power"""
+    power = int(power)
+    if power & 1:
+        return interval(inter.start**power, inter.end**power)
+    else:
+        if inter.start < 0 and inter.end > 0:
+            start = 0
+            end = max(inter.start**power, inter.end**power)
+            return interval(start, end)
+        else:
+            return interval(inter.start**power, inter.end**power)

venv/lib/python3.10/site-packages/sympy/plotting/intervalmath/interval_membership.py

@@ -0,0 +1,78 @@
+from sympy.core.logic import fuzzy_and, fuzzy_or, fuzzy_not, fuzzy_xor
+
+
+class intervalMembership:
+    """Represents a boolean expression returned by the comparison of
+    the interval object.
+
+    Parameters
+    ==========
+
+    (a, b) : (bool, bool)
+        The first value determines the comparison as follows:
+        - True: If the comparison is True throughout the intervals.
+        - False: If the comparison is False throughout the intervals.
+        - None: If the comparison is True for some part of the intervals.
+
+        The second value is determined as follows:
+        - True: If both the intervals in comparison are valid.
+        - False: If at least one of the intervals is False, else
+        - None
+    """
+    def __init__(self, a, b):
+        self._wrapped = (a, b)
+
+    def __getitem__(self, i):
+        try:
+            return self._wrapped[i]
+        except IndexError:
+            raise IndexError(
+                "{} must be a valid indexing for the 2-tuple."
+                .format(i))
+
+    def __len__(self):
+        return 2
+
+    def __iter__(self):
+        return iter(self._wrapped)
+
+    def __str__(self):
+        return "intervalMembership({}, {})".format(*self)
+    __repr__ = __str__
+
+    def __and__(self, other):
+        if not isinstance(other, intervalMembership):
+            raise ValueError(
+                "The comparison is not supported for {}.".format(other))
+
+        a1, b1 = self
+        a2, b2 = other
+        return intervalMembership(fuzzy_and([a1, a2]), fuzzy_and([b1, b2]))
+
+    def __or__(self, other):
+        if not isinstance(other, intervalMembership):
+            raise ValueError(
+                "The comparison is not supported for {}.".format(other))
+
+        a1, b1 = self
+        a2, b2 = other
+        return intervalMembership(fuzzy_or([a1, a2]), fuzzy_and([b1, b2]))
+
+    def __invert__(self):
+        a, b = self
+        return intervalMembership(fuzzy_not(a), b)
+
+    def __xor__(self, other):
+        if not isinstance(other, intervalMembership):
+            raise ValueError(
+                "The comparison is not supported for {}.".format(other))
+
+        a1, b1 = self
+        a2, b2 = other
+        return intervalMembership(fuzzy_xor([a1, a2]), fuzzy_and([b1, b2]))
+
+    def __eq__(self, other):
+        return self._wrapped == other
+
+    def __ne__(self, other):
+        return self._wrapped != other

venv/lib/python3.10/site-packages/sympy/plotting/intervalmath/lib_interval.py

@@ -0,0 +1,452 @@
+""" The module contains implemented functions for interval arithmetic."""
+from functools import reduce
+
+from sympy.plotting.intervalmath import interval
+from sympy.external import import_module
+
+
+def Abs(x):
+    if isinstance(x, (int, float)):
+        return interval(abs(x))
+    elif isinstance(x, interval):
+        if x.start < 0 and x.end > 0:
+            return interval(0, max(abs(x.start), abs(x.end)), is_valid=x.is_valid)
+        else:
+            return interval(abs(x.start), abs(x.end))
+    else:
+        raise NotImplementedError
+
+#Monotonic
+
+
+def exp(x):
+    """evaluates the exponential of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.exp(x), np.exp(x))
+    elif isinstance(x, interval):
+        return interval(np.exp(x.start), np.exp(x.end), is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+#Monotonic
+def log(x):
+    """evaluates the natural logarithm of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        if x <= 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.log(x))
+    elif isinstance(x, interval):
+        if not x.is_valid:
+            return interval(-np.inf, np.inf, is_valid=x.is_valid)
+        elif x.end <= 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        elif x.start <= 0:
+            return interval(-np.inf, np.inf, is_valid=None)
+
+        return interval(np.log(x.start), np.log(x.end))
+    else:
+        raise NotImplementedError
+
+
+#Monotonic
+def log10(x):
+    """evaluates the logarithm to the base 10 of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        if x <= 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.log10(x))
+    elif isinstance(x, interval):
+        if not x.is_valid:
+            return interval(-np.inf, np.inf, is_valid=x.is_valid)
+        elif x.end <= 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        elif x.start <= 0:
+            return interval(-np.inf, np.inf, is_valid=None)
+        return interval(np.log10(x.start), np.log10(x.end))
+    else:
+        raise NotImplementedError
+
+
+#Monotonic
+def atan(x):
+    """evaluates the tan inverse of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.arctan(x))
+    elif isinstance(x, interval):
+        start = np.arctan(x.start)
+        end = np.arctan(x.end)
+        return interval(start, end, is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+#periodic
+def sin(x):
+    """evaluates the sine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.sin(x))
+    elif isinstance(x, interval):
+        if not x.is_valid:
+            return interval(-1, 1, is_valid=x.is_valid)
+        na, __ = divmod(x.start, np.pi / 2.0)
+        nb, __ = divmod(x.end, np.pi / 2.0)
+        start = min(np.sin(x.start), np.sin(x.end))
+        end = max(np.sin(x.start), np.sin(x.end))
+        if nb - na > 4:
+            return interval(-1, 1, is_valid=x.is_valid)
+        elif na == nb:
+            return interval(start, end, is_valid=x.is_valid)
+        else:
+            if (na - 1) // 4 != (nb - 1) // 4:
+                #sin has max
+                end = 1
+            if (na - 3) // 4 != (nb - 3) // 4:
+                #sin has min
+                start = -1
+            return interval(start, end)
+    else:
+        raise NotImplementedError
+
+
+#periodic
+def cos(x):
+    """Evaluates the cos of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.sin(x))
+    elif isinstance(x, interval):
+        if not (np.isfinite(x.start) and np.isfinite(x.end)):
+            return interval(-1, 1, is_valid=x.is_valid)
+        na, __ = divmod(x.start, np.pi / 2.0)
+        nb, __ = divmod(x.end, np.pi / 2.0)
+        start = min(np.cos(x.start), np.cos(x.end))
+        end = max(np.cos(x.start), np.cos(x.end))
+        if nb - na > 4:
+            #differ more than 2*pi
+            return interval(-1, 1, is_valid=x.is_valid)
+        elif na == nb:
+            #in the same quadarant
+            return interval(start, end, is_valid=x.is_valid)
+        else:
+            if (na) // 4 != (nb) // 4:
+                #cos has max
+                end = 1
+            if (na - 2) // 4 != (nb - 2) // 4:
+                #cos has min
+                start = -1
+            return interval(start, end, is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+def tan(x):
+    """Evaluates the tan of an interval"""
+    return sin(x) / cos(x)
+
+
+#Monotonic
+def sqrt(x):
+    """Evaluates the square root of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        if x > 0:
+            return interval(np.sqrt(x))
+        else:
+            return interval(-np.inf, np.inf, is_valid=False)
+    elif isinstance(x, interval):
+        #Outside the domain
+        if x.end < 0:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #Partially outside the domain
+        elif x.start < 0:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            return interval(np.sqrt(x.start), np.sqrt(x.end),
+                    is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+def imin(*args):
+    """Evaluates the minimum of a list of intervals"""
+    np = import_module('numpy')
+    if not all(isinstance(arg, (int, float, interval)) for arg in args):
+        return NotImplementedError
+    else:
+        new_args = [a for a in args if isinstance(a, (int, float))
+                    or a.is_valid]
+        if len(new_args) == 0:
+            if all(a.is_valid is False for a in args):
+                return interval(-np.inf, np.inf, is_valid=False)
+            else:
+                return interval(-np.inf, np.inf, is_valid=None)
+        start_array = [a if isinstance(a, (int, float)) else a.start
+                       for a in new_args]
+
+        end_array = [a if isinstance(a, (int, float)) else a.end
+                     for a in new_args]
+        return interval(min(start_array), min(end_array))
+
+
+def imax(*args):
+    """Evaluates the maximum of a list of intervals"""
+    np = import_module('numpy')
+    if not all(isinstance(arg, (int, float, interval)) for arg in args):
+        return NotImplementedError
+    else:
+        new_args = [a for a in args if isinstance(a, (int, float))
+                    or a.is_valid]
+        if len(new_args) == 0:
+            if all(a.is_valid is False for a in args):
+                return interval(-np.inf, np.inf, is_valid=False)
+            else:
+                return interval(-np.inf, np.inf, is_valid=None)
+        start_array = [a if isinstance(a, (int, float)) else a.start
+                       for a in new_args]
+
+        end_array = [a if isinstance(a, (int, float)) else a.end
+                     for a in new_args]
+
+        return interval(max(start_array), max(end_array))
+
+
+#Monotonic
+def sinh(x):
+    """Evaluates the hyperbolic sine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.sinh(x), np.sinh(x))
+    elif isinstance(x, interval):
+        return interval(np.sinh(x.start), np.sinh(x.end), is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+def cosh(x):
+    """Evaluates the hyperbolic cos of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.cosh(x), np.cosh(x))
+    elif isinstance(x, interval):
+        #both signs
+        if x.start < 0 and x.end > 0:
+            end = max(np.cosh(x.start), np.cosh(x.end))
+            return interval(1, end, is_valid=x.is_valid)
+        else:
+            #Monotonic
+            start = np.cosh(x.start)
+            end = np.cosh(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+#Monotonic
+def tanh(x):
+    """Evaluates the hyperbolic tan of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.tanh(x), np.tanh(x))
+    elif isinstance(x, interval):
+        return interval(np.tanh(x.start), np.tanh(x.end), is_valid=x.is_valid)
+    else:
+        raise NotImplementedError
+
+
+def asin(x):
+    """Evaluates the inverse sine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        #Outside the domain
+        if abs(x) > 1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.arcsin(x), np.arcsin(x))
+    elif isinstance(x, interval):
+        #Outside the domain
+        if x.is_valid is False or x.start > 1 or x.end < -1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #Partially outside the domain
+        elif x.start < -1 or x.end > 1:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            start = np.arcsin(x.start)
+            end = np.arcsin(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+
+
+def acos(x):
+    """Evaluates the inverse cos of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        if abs(x) > 1:
+            #Outside the domain
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.arccos(x), np.arccos(x))
+    elif isinstance(x, interval):
+        #Outside the domain
+        if x.is_valid is False or x.start > 1 or x.end < -1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #Partially outside the domain
+        elif x.start < -1 or x.end > 1:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            start = np.arccos(x.start)
+            end = np.arccos(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+
+
+def ceil(x):
+    """Evaluates the ceiling of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.ceil(x))
+    elif isinstance(x, interval):
+        if x.is_valid is False:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            start = np.ceil(x.start)
+            end = np.ceil(x.end)
+            #Continuous over the interval
+            if start == end:
+                return interval(start, end, is_valid=x.is_valid)
+            else:
+                #Not continuous over the interval
+                return interval(start, end, is_valid=None)
+    else:
+        return NotImplementedError
+
+
+def floor(x):
+    """Evaluates the floor of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.floor(x))
+    elif isinstance(x, interval):
+        if x.is_valid is False:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            start = np.floor(x.start)
+            end = np.floor(x.end)
+            #continuous over the argument
+            if start == end:
+                return interval(start, end, is_valid=x.is_valid)
+            else:
+                #not continuous over the interval
+                return interval(start, end, is_valid=None)
+    else:
+        return NotImplementedError
+
+
+def acosh(x):
+    """Evaluates the inverse hyperbolic cosine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        #Outside the domain
+        if x < 1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.arccosh(x))
+    elif isinstance(x, interval):
+        #Outside the domain
+        if x.end < 1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #Partly outside the domain
+        elif x.start < 1:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            start = np.arccosh(x.start)
+            end = np.arccosh(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+    else:
+        return NotImplementedError
+
+
+#Monotonic
+def asinh(x):
+    """Evaluates the inverse hyperbolic sine of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        return interval(np.arcsinh(x))
+    elif isinstance(x, interval):
+        start = np.arcsinh(x.start)
+        end = np.arcsinh(x.end)
+        return interval(start, end, is_valid=x.is_valid)
+    else:
+        return NotImplementedError
+
+
+def atanh(x):
+    """Evaluates the inverse hyperbolic tangent of an interval"""
+    np = import_module('numpy')
+    if isinstance(x, (int, float)):
+        #Outside the domain
+        if abs(x) >= 1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        else:
+            return interval(np.arctanh(x))
+    elif isinstance(x, interval):
+        #outside the domain
+        if x.is_valid is False or x.start >= 1 or x.end <= -1:
+            return interval(-np.inf, np.inf, is_valid=False)
+        #partly outside the domain
+        elif x.start <= -1 or x.end >= 1:
+            return interval(-np.inf, np.inf, is_valid=None)
+        else:
+            start = np.arctanh(x.start)
+            end = np.arctanh(x.end)
+            return interval(start, end, is_valid=x.is_valid)
+    else:
+        return NotImplementedError
+
+
+#Three valued logic for interval plotting.
+
+def And(*args):
+    """Defines the three valued ``And`` behaviour for a 2-tuple of
+     three valued logic values"""
+    def reduce_and(cmp_intervala, cmp_intervalb):
+        if cmp_intervala[0] is False or cmp_intervalb[0] is False:
+            first = False
+        elif cmp_intervala[0] is None or cmp_intervalb[0] is None:
+            first = None
+        else:
+            first = True
+        if cmp_intervala[1] is False or cmp_intervalb[1] is False:
+            second = False
+        elif cmp_intervala[1] is None or cmp_intervalb[1] is None:
+            second = None
+        else:
+            second = True
+        return (first, second)
+    return reduce(reduce_and, args)
+
+
+def Or(*args):
+    """Defines the three valued ``Or`` behaviour for a 2-tuple of
+     three valued logic values"""
+    def reduce_or(cmp_intervala, cmp_intervalb):
+        if cmp_intervala[0] is True or cmp_intervalb[0] is True:
+            first = True
+        elif cmp_intervala[0] is None or cmp_intervalb[0] is None:
+            first = None
+        else:
+            first = False
+
+        if cmp_intervala[1] is True or cmp_intervalb[1] is True:
+            second = True
+        elif cmp_intervala[1] is None or cmp_intervalb[1] is None:
+            second = None
+        else:
+            second = False
+        return (first, second)
+    return reduce(reduce_or, args)

venv/lib/python3.10/site-packages/sympy/plotting/intervalmath/tests/test_interval_functions.py

@@ -0,0 +1,415 @@
+from sympy.external import import_module
+from sympy.plotting.intervalmath import (
+    Abs, acos, acosh, And, asin, asinh, atan, atanh, ceil, cos, cosh,
+    exp, floor, imax, imin, interval, log, log10, Or, sin, sinh, sqrt,
+    tan, tanh,
+)
+
+np = import_module('numpy')
+if not np:
+    disabled = True
+
+
+#requires Numpy. Hence included in interval_functions
+
+
+def test_interval_pow():
+    a = 2**interval(1, 2) == interval(2, 4)
+    assert a == (True, True)
+    a = interval(1, 2)**interval(1, 2) == interval(1, 4)
+    assert a == (True, True)
+    a = interval(-1, 1)**interval(0.5, 2)
+    assert a.is_valid is None
+    a = interval(-2, -1) ** interval(1, 2)
+    assert a.is_valid is False
+    a = interval(-2, -1) ** (1.0 / 2)
+    assert a.is_valid is False
+    a = interval(-1, 1)**(1.0 / 2)
+    assert a.is_valid is None
+    a = interval(-1, 1)**(1.0 / 3) == interval(-1, 1)
+    assert a == (True, True)
+    a = interval(-1, 1)**2 == interval(0, 1)
+    assert a == (True, True)
+    a = interval(-1, 1) ** (1.0 / 29) == interval(-1, 1)
+    assert a == (True, True)
+    a = -2**interval(1, 1) == interval(-2, -2)
+    assert a == (True, True)
+
+    a = interval(1, 2, is_valid=False)**2
+    assert a.is_valid is False
+
+    a = (-3)**interval(1, 2)
+    assert a.is_valid is False
+    a = (-4)**interval(0.5, 0.5)
+    assert a.is_valid is False
+    assert ((-3)**interval(1, 1) == interval(-3, -3)) == (True, True)
+
+    a = interval(8, 64)**(2.0 / 3)
+    assert abs(a.start - 4) < 1e-10  # eps
+    assert abs(a.end - 16) < 1e-10
+    a = interval(-8, 64)**(2.0 / 3)
+    assert abs(a.start - 4) < 1e-10  # eps
+    assert abs(a.end - 16) < 1e-10
+
+
+def test_exp():
+    a = exp(interval(-np.inf, 0))
+    assert a.start == np.exp(-np.inf)
+    assert a.end == np.exp(0)
+    a = exp(interval(1, 2))
+    assert a.start == np.exp(1)
+    assert a.end == np.exp(2)
+    a = exp(1)
+    assert a.start == np.exp(1)
+    assert a.end == np.exp(1)
+
+
+def test_log():
+    a = log(interval(1, 2))
+    assert a.start == 0
+    assert a.end == np.log(2)
+    a = log(interval(-1, 1))
+    assert a.is_valid is None
+    a = log(interval(-3, -1))
+    assert a.is_valid is False
+    a = log(-3)
+    assert a.is_valid is False
+    a = log(2)
+    assert a.start == np.log(2)
+    assert a.end == np.log(2)
+
+
+def test_log10():
+    a = log10(interval(1, 2))
+    assert a.start == 0
+    assert a.end == np.log10(2)
+    a = log10(interval(-1, 1))
+    assert a.is_valid is None
+    a = log10(interval(-3, -1))
+    assert a.is_valid is False
+    a = log10(-3)
+    assert a.is_valid is False
+    a = log10(2)
+    assert a.start == np.log10(2)
+    assert a.end == np.log10(2)
+
+
+def test_atan():
+    a = atan(interval(0, 1))
+    assert a.start == np.arctan(0)
+    assert a.end == np.arctan(1)
+    a = atan(1)
+    assert a.start == np.arctan(1)
+    assert a.end == np.arctan(1)
+
+
+def test_sin():
+    a = sin(interval(0, np.pi / 4))
+    assert a.start == np.sin(0)
+    assert a.end == np.sin(np.pi / 4)
+
+    a = sin(interval(-np.pi / 4, np.pi / 4))
+    assert a.start == np.sin(-np.pi / 4)
+    assert a.end == np.sin(np.pi / 4)
+
+    a = sin(interval(np.pi / 4, 3 * np.pi / 4))
+    assert a.start == np.sin(np.pi / 4)
+    assert a.end == 1
+
+    a = sin(interval(7 * np.pi / 6, 7 * np.pi / 4))
+    assert a.start == -1
+    assert a.end == np.sin(7 * np.pi / 6)
+
+    a = sin(interval(0, 3 * np.pi))
+    assert a.start == -1
+    assert a.end == 1
+
+    a = sin(interval(np.pi / 3, 7 * np.pi / 4))
+    assert a.start == -1
+    assert a.end == 1
+
+    a = sin(np.pi / 4)
+    assert a.start == np.sin(np.pi / 4)
+    assert a.end == np.sin(np.pi / 4)
+
+    a = sin(interval(1, 2, is_valid=False))
+    assert a.is_valid is False
+
+
+def test_cos():
+    a = cos(interval(0, np.pi / 4))
+    assert a.start == np.cos(np.pi / 4)
+    assert a.end == 1
+
+    a = cos(interval(-np.pi / 4, np.pi / 4))
+    assert a.start == np.cos(-np.pi / 4)
+    assert a.end == 1
+
+    a = cos(interval(np.pi / 4, 3 * np.pi / 4))
+    assert a.start == np.cos(3 * np.pi / 4)
+    assert a.end == np.cos(np.pi / 4)
+
+    a = cos(interval(3 * np.pi / 4, 5 * np.pi / 4))
+    assert a.start == -1
+    assert a.end == np.cos(3 * np.pi / 4)
+
+    a = cos(interval(0, 3 * np.pi))
+    assert a.start == -1
+    assert a.end == 1
+
+    a = cos(interval(- np.pi / 3, 5 * np.pi / 4))
+    assert a.start == -1
+    assert a.end == 1
+
+    a = cos(interval(1, 2, is_valid=False))
+    assert a.is_valid is False
+
+
+def test_tan():
+    a = tan(interval(0, np.pi / 4))
+    assert a.start == 0
+    # must match lib_interval definition of tan:
+    assert a.end == np.sin(np.pi / 4)/np.cos(np.pi / 4)
+
+    a = tan(interval(np.pi / 4, 3 * np.pi / 4))
+    #discontinuity
+    assert a.is_valid is None
+
+
+def test_sqrt():
+    a = sqrt(interval(1, 4))
+    assert a.start == 1
+    assert a.end == 2
+
+    a = sqrt(interval(0.01, 1))
+    assert a.start == np.sqrt(0.01)
+    assert a.end == 1
+
+    a = sqrt(interval(-1, 1))
+    assert a.is_valid is None
+
+    a = sqrt(interval(-3, -1))
+    assert a.is_valid is False
+
+    a = sqrt(4)
+    assert (a == interval(2, 2)) == (True, True)
+
+    a = sqrt(-3)
+    assert a.is_valid is False
+
+
+def test_imin():
+    a = imin(interval(1, 3), interval(2, 5), interval(-1, 3))
+    assert a.start == -1
+    assert a.end == 3
+
+    a = imin(-2, interval(1, 4))
+    assert a.start == -2
+    assert a.end == -2
+
+    a = imin(5, interval(3, 4), interval(-2, 2, is_valid=False))
+    assert a.start == 3
+    assert a.end == 4
+
+
+def test_imax():
+    a = imax(interval(-2, 2), interval(2, 7), interval(-3, 9))
+    assert a.start == 2
+    assert a.end == 9
+
+    a = imax(8, interval(1, 4))
+    assert a.start == 8
+    assert a.end == 8
+
+    a = imax(interval(1, 2), interval(3, 4), interval(-2, 2, is_valid=False))
+    assert a.start == 3
+    assert a.end == 4
+
+
+def test_sinh():
+    a = sinh(interval(-1, 1))
+    assert a.start == np.sinh(-1)
+    assert a.end == np.sinh(1)
+
+    a = sinh(1)
+    assert a.start == np.sinh(1)
+    assert a.end == np.sinh(1)
+
+
+def test_cosh():
+    a = cosh(interval(1, 2))
+    assert a.start == np.cosh(1)
+    assert a.end == np.cosh(2)
+    a = cosh(interval(-2, -1))
+    assert a.start == np.cosh(-1)
+    assert a.end == np.cosh(-2)
+
+    a = cosh(interval(-2, 1))
+    assert a.start == 1
+    assert a.end == np.cosh(-2)
+
+    a = cosh(1)
+    assert a.start == np.cosh(1)
+    assert a.end == np.cosh(1)
+
+
+def test_tanh():
+    a = tanh(interval(-3, 3))
+    assert a.start == np.tanh(-3)
+    assert a.end == np.tanh(3)
+
+    a = tanh(3)
+    assert a.start == np.tanh(3)
+    assert a.end == np.tanh(3)
+
+
+def test_asin():
+    a = asin(interval(-0.5, 0.5))
+    assert a.start == np.arcsin(-0.5)
+    assert a.end == np.arcsin(0.5)
+
+    a = asin(interval(-1.5, 1.5))
+    assert a.is_valid is None
+    a = asin(interval(-2, -1.5))
+    assert a.is_valid is False
+
+    a = asin(interval(0, 2))
+    assert a.is_valid is None
+
+    a = asin(interval(2, 5))
+    assert a.is_valid is False
+
+    a = asin(0.5)
+    assert a.start == np.arcsin(0.5)
+    assert a.end == np.arcsin(0.5)
+
+    a = asin(1.5)
+    assert a.is_valid is False
+
+
+def test_acos():
+    a = acos(interval(-0.5, 0.5))
+    assert a.start == np.arccos(0.5)
+    assert a.end == np.arccos(-0.5)
+
+    a = acos(interval(-1.5, 1.5))
+    assert a.is_valid is None
+    a = acos(interval(-2, -1.5))
+    assert a.is_valid is False
+
+    a = acos(interval(0, 2))
+    assert a.is_valid is None
+
+    a = acos(interval(2, 5))
+    assert a.is_valid is False
+
+    a = acos(0.5)
+    assert a.start == np.arccos(0.5)
+    assert a.end == np.arccos(0.5)
+
+    a = acos(1.5)
+    assert a.is_valid is False
+
+
+def test_ceil():
+    a = ceil(interval(0.2, 0.5))
+    assert a.start == 1
+    assert a.end == 1
+
+    a = ceil(interval(0.5, 1.5))
+    assert a.start == 1
+    assert a.end == 2
+    assert a.is_valid is None
+
+    a = ceil(interval(-5, 5))
+    assert a.is_valid is None
+
+    a = ceil(5.4)
+    assert a.start == 6
+    assert a.end == 6
+
+
+def test_floor():
+    a = floor(interval(0.2, 0.5))
+    assert a.start == 0
+    assert a.end == 0
+
+    a = floor(interval(0.5, 1.5))
+    assert a.start == 0
+    assert a.end == 1
+    assert a.is_valid is None
+
+    a = floor(interval(-5, 5))
+    assert a.is_valid is None
+
+    a = floor(5.4)
+    assert a.start == 5
+    assert a.end == 5
+
+
+def test_asinh():
+    a = asinh(interval(1, 2))
+    assert a.start == np.arcsinh(1)
+    assert a.end == np.arcsinh(2)
+
+    a = asinh(0.5)
+    assert a.start == np.arcsinh(0.5)
+    assert a.end == np.arcsinh(0.5)
+
+
+def test_acosh():
+    a = acosh(interval(3, 5))
+    assert a.start == np.arccosh(3)
+    assert a.end == np.arccosh(5)
+
+    a = acosh(interval(0, 3))
+    assert a.is_valid is None
+    a = acosh(interval(-3, 0.5))
+    assert a.is_valid is False
+
+    a = acosh(0.5)
+    assert a.is_valid is False
+
+    a = acosh(2)
+    assert a.start == np.arccosh(2)
+    assert a.end == np.arccosh(2)
+
+
+def test_atanh():
+    a = atanh(interval(-0.5, 0.5))
+    assert a.start == np.arctanh(-0.5)
+    assert a.end == np.arctanh(0.5)
+
+    a = atanh(interval(0, 3))
+    assert a.is_valid is None
+
+    a = atanh(interval(-3, -2))
+    assert a.is_valid is False
+
+    a = atanh(0.5)
+    assert a.start == np.arctanh(0.5)
+    assert a.end == np.arctanh(0.5)
+
+    a = atanh(1.5)
+    assert a.is_valid is False
+
+
+def test_Abs():
+    assert (Abs(interval(-0.5, 0.5)) == interval(0, 0.5)) == (True, True)
+    assert (Abs(interval(-3, -2)) == interval(2, 3)) == (True, True)
+    assert (Abs(-3) == interval(3, 3)) == (True, True)
+
+
+def test_And():
+    args = [(True, True), (True, False), (True, None)]
+    assert And(*args) == (True, False)
+
+    args = [(False, True), (None, None), (True, True)]
+    assert And(*args) == (False, None)
+
+
+def test_Or():
+    args = [(True, True), (True, False), (False, None)]
+    assert Or(*args) == (True, True)
+    args = [(None, None), (False, None), (False, False)]
+    assert Or(*args) == (None, None)

venv/lib/python3.10/site-packages/sympy/plotting/intervalmath/tests/test_interval_membership.py

@@ -0,0 +1,150 @@
+from sympy.core.symbol import Symbol
+from sympy.plotting.intervalmath import interval
+from sympy.plotting.intervalmath.interval_membership import intervalMembership
+from sympy.plotting.experimental_lambdify import experimental_lambdify
+from sympy.testing.pytest import raises
+
+
+def test_creation():
+    assert intervalMembership(True, True)
+    raises(TypeError, lambda: intervalMembership(True))
+    raises(TypeError, lambda: intervalMembership(True, True, True))
+
+
+def test_getitem():
+    a = intervalMembership(True, False)
+    assert a[0] is True
+    assert a[1] is False
+    raises(IndexError, lambda: a[2])
+
+
+def test_str():
+    a = intervalMembership(True, False)
+    assert str(a) == 'intervalMembership(True, False)'
+    assert repr(a) == 'intervalMembership(True, False)'
+
+
+def test_equivalence():
+    a = intervalMembership(True, True)
+    b = intervalMembership(True, False)
+    assert (a == b) is False
+    assert (a != b) is True
+
+    a = intervalMembership(True, False)
+    b = intervalMembership(True, False)
+    assert (a == b) is True
+    assert (a != b) is False
+
+
+def test_not():
+    x = Symbol('x')
+
+    r1 = x > -1
+    r2 = x <= -1
+
+    i = interval
+
+    f1 = experimental_lambdify((x,), r1)
+    f2 = experimental_lambdify((x,), r2)
+
+    tt = i(-0.1, 0.1, is_valid=True)
+    tn = i(-0.1, 0.1, is_valid=None)
+    tf = i(-0.1, 0.1, is_valid=False)
+
+    assert f1(tt) == ~f2(tt)
+    assert f1(tn) == ~f2(tn)
+    assert f1(tf) == ~f2(tf)
+
+    nt = i(0.9, 1.1, is_valid=True)
+    nn = i(0.9, 1.1, is_valid=None)
+    nf = i(0.9, 1.1, is_valid=False)
+
+    assert f1(nt) == ~f2(nt)
+    assert f1(nn) == ~f2(nn)
+    assert f1(nf) == ~f2(nf)
+
+    ft = i(1.9, 2.1, is_valid=True)
+    fn = i(1.9, 2.1, is_valid=None)
+    ff = i(1.9, 2.1, is_valid=False)
+
+    assert f1(ft) == ~f2(ft)
+    assert f1(fn) == ~f2(fn)
+    assert f1(ff) == ~f2(ff)
+
+
+def test_boolean():
+    # There can be 9*9 test cases in full mapping of the cartesian product.
+    # But we only consider 3*3 cases for simplicity.
+    s = [
+        intervalMembership(False, False),
+        intervalMembership(None, None),
+        intervalMembership(True, True)
+    ]
+
+    # Reduced tests for 'And'
+    a1 = [
+        intervalMembership(False, False),
+        intervalMembership(False, False),
+        intervalMembership(False, False),
+        intervalMembership(False, False),
+        intervalMembership(None, None),
+        intervalMembership(None, None),
+        intervalMembership(False, False),
+        intervalMembership(None, None),
+        intervalMembership(True, True)
+    ]
+    a1_iter = iter(a1)
+    for i in range(len(s)):
+        for j in range(len(s)):
+            assert s[i] & s[j] == next(a1_iter)
+
+    # Reduced tests for 'Or'
+    a1 = [
+        intervalMembership(False, False),
+        intervalMembership(None, False),
+        intervalMembership(True, False),
+        intervalMembership(None, False),
+        intervalMembership(None, None),
+        intervalMembership(True, None),
+        intervalMembership(True, False),
+        intervalMembership(True, None),
+        intervalMembership(True, True)
+    ]
+    a1_iter = iter(a1)
+    for i in range(len(s)):
+        for j in range(len(s)):
+            assert s[i] | s[j] == next(a1_iter)
+
+    # Reduced tests for 'Xor'
+    a1 = [
+        intervalMembership(False, False),
+        intervalMembership(None, False),
+        intervalMembership(True, False),
+        intervalMembership(None, False),
+        intervalMembership(None, None),
+        intervalMembership(None, None),
+        intervalMembership(True, False),
+        intervalMembership(None, None),
+        intervalMembership(False, True)
+    ]
+    a1_iter = iter(a1)
+    for i in range(len(s)):
+        for j in range(len(s)):
+            assert s[i] ^ s[j] == next(a1_iter)
+
+    # Reduced tests for 'Not'
+    a1 = [
+        intervalMembership(True, False),
+        intervalMembership(None, None),
+        intervalMembership(False, True)
+    ]
+    a1_iter = iter(a1)
+    for i in range(len(s)):
+        assert ~s[i] == next(a1_iter)
+
+
+def test_boolean_errors():
+    a = intervalMembership(True, True)
+    raises(ValueError, lambda: a & 1)
+    raises(ValueError, lambda: a | 1)
+    raises(ValueError, lambda: a ^ 1)

venv/lib/python3.10/site-packages/sympy/plotting/intervalmath/tests/test_intervalmath.py

@@ -0,0 +1,213 @@
+from sympy.plotting.intervalmath import interval
+from sympy.testing.pytest import raises
+
+
+def test_interval():
+    assert (interval(1, 1) == interval(1, 1, is_valid=True)) == (True, True)
+    assert (interval(1, 1) == interval(1, 1, is_valid=False)) == (True, False)
+    assert (interval(1, 1) == interval(1, 1, is_valid=None)) == (True, None)
+    assert (interval(1, 1.5) == interval(1, 2)) == (None, True)
+    assert (interval(0, 1) == interval(2, 3)) == (False, True)
+    assert (interval(0, 1) == interval(1, 2)) == (None, True)
+    assert (interval(1, 2) != interval(1, 2)) == (False, True)
+    assert (interval(1, 3) != interval(2, 3)) == (None, True)
+    assert (interval(1, 3) != interval(-5, -3)) == (True, True)
+    assert (
+        interval(1, 3, is_valid=False) != interval(-5, -3)) == (True, False)
+    assert (interval(1, 3, is_valid=None) != interval(-5, 3)) == (None, None)
+    assert (interval(4, 4) != 4) == (False, True)
+    assert (interval(1, 1) == 1) == (True, True)
+    assert (interval(1, 3, is_valid=False) == interval(1, 3)) == (True, False)
+    assert (interval(1, 3, is_valid=None) == interval(1, 3)) == (True, None)
+    inter = interval(-5, 5)
+    assert (interval(inter) == interval(-5, 5)) == (True, True)
+    assert inter.width == 10
+    assert 0 in inter
+    assert -5 in inter
+    assert 5 in inter
+    assert interval(0, 3) in inter
+    assert interval(-6, 2) not in inter
+    assert -5.05 not in inter
+    assert 5.3 not in inter
+    interb = interval(-float('inf'), float('inf'))
+    assert 0 in inter
+    assert inter in interb
+    assert interval(0, float('inf')) in interb
+    assert interval(-float('inf'), 5) in interb
+    assert interval(-1e50, 1e50) in interb
+    assert (
+        -interval(-1, -2, is_valid=False) == interval(1, 2)) == (True, False)
+    raises(ValueError, lambda: interval(1, 2, 3))
+
+
+def test_interval_add():
+    assert (interval(1, 2) + interval(2, 3) == interval(3, 5)) == (True, True)
+    assert (1 + interval(1, 2) == interval(2, 3)) == (True, True)
+    assert (interval(1, 2) + 1 == interval(2, 3)) == (True, True)
+    compare = (1 + interval(0, float('inf')) == interval(1, float('inf')))
+    assert compare == (True, True)
+    a = 1 + interval(2, 5, is_valid=False)
+    assert a.is_valid is False
+    a = 1 + interval(2, 5, is_valid=None)
+    assert a.is_valid is None
+    a = interval(2, 5, is_valid=False) + interval(3, 5, is_valid=None)
+    assert a.is_valid is False
+    a = interval(3, 5) + interval(-1, 1, is_valid=None)
+    assert a.is_valid is None
+    a = interval(2, 5, is_valid=False) + 1
+    assert a.is_valid is False
+
+
+def test_interval_sub():
+    assert (interval(1, 2) - interval(1, 5) == interval(-4, 1)) == (True, True)
+    assert (interval(1, 2) - 1 == interval(0, 1)) == (True, True)
+    assert (1 - interval(1, 2) == interval(-1, 0)) == (True, True)
+    a = 1 - interval(1, 2, is_valid=False)
+    assert a.is_valid is False
+    a = interval(1, 4, is_valid=None) - 1
+    assert a.is_valid is None
+    a = interval(1, 3, is_valid=False) - interval(1, 3)
+    assert a.is_valid is False
+    a = interval(1, 3, is_valid=None) - interval(1, 3)
+    assert a.is_valid is None
+
+
+def test_interval_inequality():
+    assert (interval(1, 2) < interval(3, 4)) == (True, True)
+    assert (interval(1, 2) < interval(2, 4)) == (None, True)
+    assert (interval(1, 2) < interval(-2, 0)) == (False, True)
+    assert (interval(1, 2) <= interval(2, 4)) == (True, True)
+    assert (interval(1, 2) <= interval(1.5, 6)) == (None, True)
+    assert (interval(2, 3) <= interval(1, 2)) == (None, True)
+    assert (interval(2, 3) <= interval(1, 1.5)) == (False, True)
+    assert (
+        interval(1, 2, is_valid=False) <= interval(-2, 0)) == (False, False)
+    assert (interval(1, 2, is_valid=None) <= interval(-2, 0)) == (False, None)
+    assert (interval(1, 2) <= 1.5) == (None, True)
+    assert (interval(1, 2) <= 3) == (True, True)
+    assert (interval(1, 2) <= 0) == (False, True)
+    assert (interval(5, 8) > interval(2, 3)) == (True, True)
+    assert (interval(2, 5) > interval(1, 3)) == (None, True)
+    assert (interval(2, 3) > interval(3.1, 5)) == (False, True)
+
+    assert (interval(-1, 1) == 0) == (None, True)
+    assert (interval(-1, 1) == 2) == (False, True)
+    assert (interval(-1, 1) != 0) == (None, True)
+    assert (interval(-1, 1) != 2) == (True, True)
+
+    assert (interval(3, 5) > 2) == (True, True)
+    assert (interval(3, 5) < 2) == (False, True)
+    assert (interval(1, 5) < 2) == (None, True)
+    assert (interval(1, 5) > 2) == (None, True)
+    assert (interval(0, 1) > 2) == (False, True)
+    assert (interval(1, 2) >= interval(0, 1)) == (True, True)
+    assert (interval(1, 2) >= interval(0, 1.5)) == (None, True)
+    assert (interval(1, 2) >= interval(3, 4)) == (False, True)
+    assert (interval(1, 2) >= 0) == (True, True)
+    assert (interval(1, 2) >= 1.2) == (None, True)
+    assert (interval(1, 2) >= 3) == (False, True)
+    assert (2 > interval(0, 1)) == (True, True)
+    a = interval(-1, 1, is_valid=False) < interval(2, 5, is_valid=None)
+    assert a == (True, False)
+    a = interval(-1, 1, is_valid=None) < interval(2, 5, is_valid=False)
+    assert a == (True, False)
+    a = interval(-1, 1, is_valid=None) < interval(2, 5, is_valid=None)
+    assert a == (True, None)
+    a = interval(-1, 1, is_valid=False) > interval(-5, -2, is_valid=None)
+    assert a == (True, False)
+    a = interval(-1, 1, is_valid=None) > interval(-5, -2, is_valid=False)
+    assert a == (True, False)
+    a = interval(-1, 1, is_valid=None) > interval(-5, -2, is_valid=None)
+    assert a == (True, None)
+
+
+def test_interval_mul():
+    assert (
+        interval(1, 5) * interval(2, 10) == interval(2, 50)) == (True, True)
+    a = interval(-1, 1) * interval(2, 10) == interval(-10, 10)
+    assert a == (True, True)
+
+    a = interval(-1, 1) * interval(-5, 3) == interval(-5, 5)
+    assert a == (True, True)
+
+    assert (interval(1, 3) * 2 == interval(2, 6)) == (True, True)
+    assert (3 * interval(-1, 2) == interval(-3, 6)) == (True, True)
+
+    a = 3 * interval(1, 2, is_valid=False)
+    assert a.is_valid is False
+
+    a = 3 * interval(1, 2, is_valid=None)
+    assert a.is_valid is None
+
+    a = interval(1, 5, is_valid=False) * interval(1, 2, is_valid=None)
+    assert a.is_valid is False
+
+
+def test_interval_div():
+    div = interval(1, 2, is_valid=False) / 3
+    assert div == interval(-float('inf'), float('inf'), is_valid=False)
+
+    div = interval(1, 2, is_valid=None) / 3
+    assert div == interval(-float('inf'), float('inf'), is_valid=None)
+
+    div = 3 / interval(1, 2, is_valid=None)
+    assert div == interval(-float('inf'), float('inf'), is_valid=None)
+    a = interval(1, 2) / 0
+    assert a.is_valid is False
+    a = interval(0.5, 1) / interval(-1, 0)
+    assert a.is_valid is None
+    a = interval(0, 1) / interval(0, 1)
+    assert a.is_valid is None
+
+    a = interval(-1, 1) / interval(-1, 1)
+    assert a.is_valid is None
+
+    a = interval(-1, 2) / interval(0.5, 1) == interval(-2.0, 4.0)
+    assert a == (True, True)
+    a = interval(0, 1) / interval(0.5, 1) == interval(0.0, 2.0)
+    assert a == (True, True)
+    a = interval(-1, 0) / interval(0.5, 1) == interval(-2.0, 0.0)
+    assert a == (True, True)
+    a = interval(-0.5, -0.25) / interval(0.5, 1) == interval(-1.0, -0.25)
+    assert a == (True, True)
+    a = interval(0.5, 1) / interval(0.5, 1) == interval(0.5, 2.0)
+    assert a == (True, True)
+    a = interval(0.5, 4) / interval(0.5, 1) == interval(0.5, 8.0)
+    assert a == (True, True)
+    a = interval(-1, -0.5) / interval(0.5, 1) == interval(-2.0, -0.5)
+    assert a == (True, True)
+    a = interval(-4, -0.5) / interval(0.5, 1) == interval(-8.0, -0.5)
+    assert a == (True, True)
+    a = interval(-1, 2) / interval(-2, -0.5) == interval(-4.0, 2.0)
+    assert a == (True, True)
+    a = interval(0, 1) / interval(-2, -0.5) == interval(-2.0, 0.0)
+    assert a == (True, True)
+    a = interval(-1, 0) / interval(-2, -0.5) == interval(0.0, 2.0)
+    assert a == (True, True)
+    a = interval(-0.5, -0.25) / interval(-2, -0.5) == interval(0.125, 1.0)
+    assert a == (True, True)
+    a = interval(0.5, 1) / interval(-2, -0.5) == interval(-2.0, -0.25)
+    assert a == (True, True)
+    a = interval(0.5, 4) / interval(-2, -0.5) == interval(-8.0, -0.25)
+    assert a == (True, True)
+    a = interval(-1, -0.5) / interval(-2, -0.5) == interval(0.25, 2.0)
+    assert a == (True, True)
+    a = interval(-4, -0.5) / interval(-2, -0.5) == interval(0.25, 8.0)
+    assert a == (True, True)
+    a = interval(-5, 5, is_valid=False) / 2
+    assert a.is_valid is False
+
+def test_hashable():
+    '''
+    test that interval objects are hashable.
+    this is required in order to be able to put them into the cache, which
+    appears to be necessary for plotting in py3k. For details, see:
+
+    https://github.com/sympy/sympy/pull/2101
+    https://github.com/sympy/sympy/issues/6533
+    '''
+    hash(interval(1, 1))
+    hash(interval(1, 1, is_valid=True))
+    hash(interval(-4, -0.5))
+    hash(interval(-2, -0.5))
+    hash(interval(0.25, 8.0))

venv/lib/python3.10/site-packages/sympy/plotting/pygletplot/tests/test_plotting.py

@@ -0,0 +1,88 @@
+from sympy.external.importtools import import_module
+
+disabled = False
+
+# if pyglet.gl fails to import, e.g. opengl is missing, we disable the tests
+pyglet_gl = import_module("pyglet.gl", catch=(OSError,))
+pyglet_window = import_module("pyglet.window", catch=(OSError,))
+if not pyglet_gl or not pyglet_window:
+    disabled = True
+
+
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.trigonometric import (cos, sin)
+x, y, z = symbols('x, y, z')
+
+
+def test_plot_2d():
+    from sympy.plotting.pygletplot import PygletPlot
+    p = PygletPlot(x, [x, -5, 5, 4], visible=False)
+    p.wait_for_calculations()
+
+
+def test_plot_2d_discontinuous():
+    from sympy.plotting.pygletplot import PygletPlot
+    p = PygletPlot(1/x, [x, -1, 1, 2], visible=False)
+    p.wait_for_calculations()
+
+
+def test_plot_3d():
+    from sympy.plotting.pygletplot import PygletPlot
+    p = PygletPlot(x*y, [x, -5, 5, 5], [y, -5, 5, 5], visible=False)
+    p.wait_for_calculations()
+
+
+def test_plot_3d_discontinuous():
+    from sympy.plotting.pygletplot import PygletPlot
+    p = PygletPlot(1/x, [x, -3, 3, 6], [y, -1, 1, 1], visible=False)
+    p.wait_for_calculations()
+
+
+def test_plot_2d_polar():
+    from sympy.plotting.pygletplot import PygletPlot
+    p = PygletPlot(1/x, [x, -1, 1, 4], 'mode=polar', visible=False)
+    p.wait_for_calculations()
+
+
+def test_plot_3d_cylinder():
+    from sympy.plotting.pygletplot import PygletPlot
+    p = PygletPlot(
+        1/y, [x, 0, 6.282, 4], [y, -1, 1, 4], 'mode=polar;style=solid',
+        visible=False)
+    p.wait_for_calculations()
+
+
+def test_plot_3d_spherical():
+    from sympy.plotting.pygletplot import PygletPlot
+    p = PygletPlot(
+        1, [x, 0, 6.282, 4], [y, 0, 3.141,
+            4], 'mode=spherical;style=wireframe',
+        visible=False)
+    p.wait_for_calculations()
+
+
+def test_plot_2d_parametric():
+    from sympy.plotting.pygletplot import PygletPlot
+    p = PygletPlot(sin(x), cos(x), [x, 0, 6.282, 4], visible=False)
+    p.wait_for_calculations()
+
+
+def test_plot_3d_parametric():
+    from sympy.plotting.pygletplot import PygletPlot
+    p = PygletPlot(sin(x), cos(x), x/5.0, [x, 0, 6.282, 4], visible=False)
+    p.wait_for_calculations()
+
+
+def _test_plot_log():
+    from sympy.plotting.pygletplot import PygletPlot
+    p = PygletPlot(log(x), [x, 0, 6.282, 4], 'mode=polar', visible=False)
+    p.wait_for_calculations()
+
+
+def test_plot_integral():
+    # Make sure it doesn't treat x as an independent variable
+    from sympy.plotting.pygletplot import PygletPlot
+    from sympy.integrals.integrals import Integral
+    p = PygletPlot(Integral(z*x, (x, 1, z), (z, 1, y)), visible=False)
+    p.wait_for_calculations()

venv/lib/python3.10/site-packages/sympy/plotting/tests/test_experimental_lambdify.py

@@ -0,0 +1,77 @@
+from sympy.core.symbol import symbols, Symbol
+from sympy.functions import Max
+from sympy.plotting.experimental_lambdify import experimental_lambdify
+from sympy.plotting.intervalmath.interval_arithmetic import \
+    interval, intervalMembership
+
+
+# Tests for exception handling in experimental_lambdify
+def test_experimental_lambify():
+    x = Symbol('x')
+    f = experimental_lambdify([x], Max(x, 5))
+    # XXX should f be tested? If f(2) is attempted, an
+    # error is raised because a complex produced during wrapping of the arg
+    # is being compared with an int.
+    assert Max(2, 5) == 5
+    assert Max(5, 7) == 7
+
+    x = Symbol('x-3')
+    f = experimental_lambdify([x], x + 1)
+    assert f(1) == 2
+
+
+def test_composite_boolean_region():
+    x, y = symbols('x y')
+
+    r1 = (x - 1)**2 + y**2 < 2
+    r2 = (x + 1)**2 + y**2 < 2
+
+    f = experimental_lambdify((x, y), r1 & r2)
+    a = (interval(-0.1, 0.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(True, True)
+    a = (interval(-1.1, -0.9), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(0.9, 1.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(-0.1, 0.1), interval(1.9, 2.1))
+    assert f(*a) == intervalMembership(False, True)
+
+    f = experimental_lambdify((x, y), r1 | r2)
+    a = (interval(-0.1, 0.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(True, True)
+    a = (interval(-1.1, -0.9), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(True, True)
+    a = (interval(0.9, 1.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(True, True)
+    a = (interval(-0.1, 0.1), interval(1.9, 2.1))
+    assert f(*a) == intervalMembership(False, True)
+
+    f = experimental_lambdify((x, y), r1 & ~r2)
+    a = (interval(-0.1, 0.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(-1.1, -0.9), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(0.9, 1.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(True, True)
+    a = (interval(-0.1, 0.1), interval(1.9, 2.1))
+    assert f(*a) == intervalMembership(False, True)
+
+    f = experimental_lambdify((x, y), ~r1 & r2)
+    a = (interval(-0.1, 0.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(-1.1, -0.9), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(True, True)
+    a = (interval(0.9, 1.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(-0.1, 0.1), interval(1.9, 2.1))
+    assert f(*a) == intervalMembership(False, True)
+
+    f = experimental_lambdify((x, y), ~r1 & ~r2)
+    a = (interval(-0.1, 0.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(-1.1, -0.9), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(0.9, 1.1), interval(-0.1, 0.1))
+    assert f(*a) == intervalMembership(False, True)
+    a = (interval(-0.1, 0.1), interval(1.9, 2.1))
+    assert f(*a) == intervalMembership(True, True)

venv/lib/python3.10/site-packages/sympy/plotting/tests/test_plot.py

@@ -0,0 +1,764 @@
+import os
+from tempfile import TemporaryDirectory
+
+from sympy.concrete.summations import Sum
+from sympy.core.numbers import (I, oo, pi)
+from sympy.core.relational import Ne
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (LambertW, exp, exp_polar, log)
+from sympy.functions.elementary.miscellaneous import (real_root, sqrt)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.hyper import meijerg
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import And
+from sympy.core.singleton import S
+from sympy.core.sympify import sympify
+from sympy.external import import_module
+from sympy.plotting.plot import (
+    Plot, plot, plot_parametric, plot3d_parametric_line, plot3d,
+    plot3d_parametric_surface)
+from sympy.plotting.plot import (
+    unset_show, plot_contour, PlotGrid, DefaultBackend, MatplotlibBackend,
+    TextBackend, BaseBackend)
+from sympy.testing.pytest import skip, raises, warns, warns_deprecated_sympy
+from sympy.utilities import lambdify as lambdify_
+from sympy.utilities.exceptions import ignore_warnings
+
+
+unset_show()
+
+
+matplotlib = import_module(
+    'matplotlib', min_module_version='1.1.0', catch=(RuntimeError,))
+
+
+class DummyBackendNotOk(BaseBackend):
+    """ Used to verify if users can create their own backends.
+    This backend is meant to raise NotImplementedError for methods `show`,
+    `save`, `close`.
+    """
+    pass
+
+
+class DummyBackendOk(BaseBackend):
+    """ Used to verify if users can create their own backends.
+    This backend is meant to pass all tests.
+    """
+    def show(self):
+        pass
+
+    def save(self):
+        pass
+
+    def close(self):
+        pass
+
+
+def test_plot_and_save_1():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    y = Symbol('y')
+
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        ###
+        # Examples from the 'introduction' notebook
+        ###
+        p = plot(x, legend=True, label='f1')
+        p = plot(x*sin(x), x*cos(x), label='f2')
+        p.extend(p)
+        p[0].line_color = lambda a: a
+        p[1].line_color = 'b'
+        p.title = 'Big title'
+        p.xlabel = 'the x axis'
+        p[1].label = 'straight line'
+        p.legend = True
+        p.aspect_ratio = (1, 1)
+        p.xlim = (-15, 20)
+        filename = 'test_basic_options_and_colors.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p.extend(plot(x + 1))
+        p.append(plot(x + 3, x**2)[1])
+        filename = 'test_plot_extend_append.png'
+        p.save(os.path.join(tmpdir, filename))
+
+        p[2] = plot(x**2, (x, -2, 3))
+        filename = 'test_plot_setitem.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot(sin(x), (x, -2*pi, 4*pi))
+        filename = 'test_line_explicit.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot(sin(x))
+        filename = 'test_line_default_range.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot((x**2, (x, -5, 5)), (x**3, (x, -3, 3)))
+        filename = 'test_line_multiple_range.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        raises(ValueError, lambda: plot(x, y))
+
+        #Piecewise plots
+        p = plot(Piecewise((1, x > 0), (0, True)), (x, -1, 1))
+        filename = 'test_plot_piecewise.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot(Piecewise((x, x < 1), (x**2, True)), (x, -3, 3))
+        filename = 'test_plot_piecewise_2.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # test issue 7471
+        p1 = plot(x)
+        p2 = plot(3)
+        p1.extend(p2)
+        filename = 'test_horizontal_line.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # test issue 10925
+        f = Piecewise((-1, x < -1), (x, And(-1 <= x, x < 0)), \
+            (x**2, And(0 <= x, x < 1)), (x**3, x >= 1))
+        p = plot(f, (x, -3, 3))
+        filename = 'test_plot_piecewise_3.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+
+def test_plot_and_save_2():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    y = Symbol('y')
+    z = Symbol('z')
+
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        #parametric 2d plots.
+        #Single plot with default range.
+        p = plot_parametric(sin(x), cos(x))
+        filename = 'test_parametric.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        #Single plot with range.
+        p = plot_parametric(
+            sin(x), cos(x), (x, -5, 5), legend=True, label='parametric_plot')
+        filename = 'test_parametric_range.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        #Multiple plots with same range.
+        p = plot_parametric((sin(x), cos(x)), (x, sin(x)))
+        filename = 'test_parametric_multiple.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        #Multiple plots with different ranges.
+        p = plot_parametric(
+            (sin(x), cos(x), (x, -3, 3)), (x, sin(x), (x, -5, 5)))
+        filename = 'test_parametric_multiple_ranges.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        #depth of recursion specified.
+        p = plot_parametric(x, sin(x), depth=13)
+        filename = 'test_recursion_depth.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        #No adaptive sampling.
+        p = plot_parametric(cos(x), sin(x), adaptive=False, nb_of_points=500)
+        filename = 'test_adaptive.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        #3d parametric plots
+        p = plot3d_parametric_line(
+            sin(x), cos(x), x, legend=True, label='3d_parametric_plot')
+        filename = 'test_3d_line.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot3d_parametric_line(
+            (sin(x), cos(x), x, (x, -5, 5)), (cos(x), sin(x), x, (x, -3, 3)))
+        filename = 'test_3d_line_multiple.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot3d_parametric_line(sin(x), cos(x), x, nb_of_points=30)
+        filename = 'test_3d_line_points.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # 3d surface single plot.
+        p = plot3d(x * y)
+        filename = 'test_surface.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Multiple 3D plots with same range.
+        p = plot3d(-x * y, x * y, (x, -5, 5))
+        filename = 'test_surface_multiple.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Multiple 3D plots with different ranges.
+        p = plot3d(
+            (x * y, (x, -3, 3), (y, -3, 3)), (-x * y, (x, -3, 3), (y, -3, 3)))
+        filename = 'test_surface_multiple_ranges.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Single Parametric 3D plot
+        p = plot3d_parametric_surface(sin(x + y), cos(x - y), x - y)
+        filename = 'test_parametric_surface.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Multiple Parametric 3D plots.
+        p = plot3d_parametric_surface(
+            (x*sin(z), x*cos(z), z, (x, -5, 5), (z, -5, 5)),
+            (sin(x + y), cos(x - y), x - y, (x, -5, 5), (y, -5, 5)))
+        filename = 'test_parametric_surface.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Single Contour plot.
+        p = plot_contour(sin(x)*sin(y), (x, -5, 5), (y, -5, 5))
+        filename = 'test_contour_plot.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Multiple Contour plots with same range.
+        p = plot_contour(x**2 + y**2, x**3 + y**3, (x, -5, 5), (y, -5, 5))
+        filename = 'test_contour_plot.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # Multiple Contour plots with different range.
+        p = plot_contour(
+            (x**2 + y**2, (x, -5, 5), (y, -5, 5)),
+            (x**3 + y**3, (x, -3, 3), (y, -3, 3)))
+        filename = 'test_contour_plot.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+
+def test_plot_and_save_3():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    y = Symbol('y')
+    z = Symbol('z')
+
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        ###
+        # Examples from the 'colors' notebook
+        ###
+
+        p = plot(sin(x))
+        p[0].line_color = lambda a: a
+        filename = 'test_colors_line_arity1.png'
+        p.save(os.path.join(tmpdir, filename))
+
+        p[0].line_color = lambda a, b: b
+        filename = 'test_colors_line_arity2.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot(x*sin(x), x*cos(x), (x, 0, 10))
+        p[0].line_color = lambda a: a
+        filename = 'test_colors_param_line_arity1.png'
+        p.save(os.path.join(tmpdir, filename))
+
+        p[0].line_color = lambda a, b: a
+        filename = 'test_colors_param_line_arity1.png'
+        p.save(os.path.join(tmpdir, filename))
+
+        p[0].line_color = lambda a, b: b
+        filename = 'test_colors_param_line_arity2b.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot3d_parametric_line(sin(x) + 0.1*sin(x)*cos(7*x),
+                cos(x) + 0.1*cos(x)*cos(7*x),
+            0.1*sin(7*x),
+            (x, 0, 2*pi))
+        p[0].line_color = lambdify_(x, sin(4*x))
+        filename = 'test_colors_3d_line_arity1.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].line_color = lambda a, b: b
+        filename = 'test_colors_3d_line_arity2.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].line_color = lambda a, b, c: c
+        filename = 'test_colors_3d_line_arity3.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot3d(sin(x)*y, (x, 0, 6*pi), (y, -5, 5))
+        p[0].surface_color = lambda a: a
+        filename = 'test_colors_surface_arity1.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].surface_color = lambda a, b: b
+        filename = 'test_colors_surface_arity2.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].surface_color = lambda a, b, c: c
+        filename = 'test_colors_surface_arity3a.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].surface_color = lambdify_((x, y, z), sqrt((x - 3*pi)**2 + y**2))
+        filename = 'test_colors_surface_arity3b.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot3d_parametric_surface(x * cos(4 * y), x * sin(4 * y), y,
+                (x, -1, 1), (y, -1, 1))
+        p[0].surface_color = lambda a: a
+        filename = 'test_colors_param_surf_arity1.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].surface_color = lambda a, b: a*b
+        filename = 'test_colors_param_surf_arity2.png'
+        p.save(os.path.join(tmpdir, filename))
+        p[0].surface_color = lambdify_((x, y, z), sqrt(x**2 + y**2 + z**2))
+        filename = 'test_colors_param_surf_arity3.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+
+def test_plot_and_save_4():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    y = Symbol('y')
+
+    ###
+    # Examples from the 'advanced' notebook
+    ###
+
+    # XXX: This raises the warning "The evaluation of the expression is
+    # problematic. We are trying a failback method that may still work. Please
+    # report this as a bug." It has to use the fallback because using evalf()
+    # is the only way to evaluate the integral. We should perhaps just remove
+    # that warning.
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        with warns(
+            UserWarning,
+            match="The evaluation of the expression is problematic",
+            test_stacklevel=False,
+        ):
+            i = Integral(log((sin(x)**2 + 1)*sqrt(x**2 + 1)), (x, 0, y))
+            p = plot(i, (y, 1, 5))
+            filename = 'test_advanced_integral.png'
+            p.save(os.path.join(tmpdir, filename))
+            p._backend.close()
+
+
+def test_plot_and_save_5():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    y = Symbol('y')
+
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        s = Sum(1/x**y, (x, 1, oo))
+        p = plot(s, (y, 2, 10))
+        filename = 'test_advanced_inf_sum.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p = plot(Sum(1/x, (x, 1, y)), (y, 2, 10), show=False)
+        p[0].only_integers = True
+        p[0].steps = True
+        filename = 'test_advanced_fin_sum.png'
+
+        # XXX: This should be fixed in experimental_lambdify or by using
+        # ordinary lambdify so that it doesn't warn. The error results from
+        # passing an array of values as the integration limit.
+        #
+        # UserWarning: The evaluation of the expression is problematic. We are
+        # trying a failback method that may still work. Please report this as a
+        # bug.
+        with ignore_warnings(UserWarning):
+            p.save(os.path.join(tmpdir, filename))
+
+        p._backend.close()
+
+
+def test_plot_and_save_6():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        filename = 'test.png'
+        ###
+        # Test expressions that can not be translated to np and generate complex
+        # results.
+        ###
+        p = plot(sin(x) + I*cos(x))
+        p.save(os.path.join(tmpdir, filename))
+
+        with ignore_warnings(RuntimeWarning):
+            p = plot(sqrt(sqrt(-x)))
+            p.save(os.path.join(tmpdir, filename))
+
+        p = plot(LambertW(x))
+        p.save(os.path.join(tmpdir, filename))
+        p = plot(sqrt(LambertW(x)))
+        p.save(os.path.join(tmpdir, filename))
+
+        #Characteristic function of a StudentT distribution with nu=10
+        x1 = 5 * x**2 * exp_polar(-I*pi)/2
+        m1 = meijerg(((1 / 2,), ()), ((5, 0, 1 / 2), ()), x1)
+        x2 = 5*x**2 * exp_polar(I*pi)/2
+        m2 = meijerg(((1/2,), ()), ((5, 0, 1/2), ()), x2)
+        expr = (m1 + m2) / (48 * pi)
+        p = plot(expr, (x, 1e-6, 1e-2))
+        p.save(os.path.join(tmpdir, filename))
+
+
+def test_plotgrid_and_save():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    y = Symbol('y')
+
+    with TemporaryDirectory(prefix='sympy_') as tmpdir:
+        p1 = plot(x)
+        p2 = plot_parametric((sin(x), cos(x)), (x, sin(x)), show=False)
+        p3 = plot_parametric(
+            cos(x), sin(x), adaptive=False, nb_of_points=500, show=False)
+        p4 = plot3d_parametric_line(sin(x), cos(x), x, show=False)
+        # symmetric grid
+        p = PlotGrid(2, 2, p1, p2, p3, p4)
+        filename = 'test_grid1.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        # grid size greater than the number of subplots
+        p = PlotGrid(3, 4, p1, p2, p3, p4)
+        filename = 'test_grid2.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+        p5 = plot(cos(x),(x, -pi, pi), show=False)
+        p5[0].line_color = lambda a: a
+        p6 = plot(Piecewise((1, x > 0), (0, True)), (x, -1, 1), show=False)
+        p7 = plot_contour(
+            (x**2 + y**2, (x, -5, 5), (y, -5, 5)),
+            (x**3 + y**3, (x, -3, 3), (y, -3, 3)), show=False)
+        # unsymmetric grid (subplots in one line)
+        p = PlotGrid(1, 3, p5, p6, p7)
+        filename = 'test_grid3.png'
+        p.save(os.path.join(tmpdir, filename))
+        p._backend.close()
+
+
+def test_append_issue_7140():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    p1 = plot(x)
+    p2 = plot(x**2)
+    plot(x + 2)
+
+    # append a series
+    p2.append(p1[0])
+    assert len(p2._series) == 2
+
+    with raises(TypeError):
+        p1.append(p2)
+
+    with raises(TypeError):
+        p1.append(p2._series)
+
+
+def test_issue_15265():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    eqn = sin(x)
+
+    p = plot(eqn, xlim=(-S.Pi, S.Pi), ylim=(-1, 1))
+    p._backend.close()
+
+    p = plot(eqn, xlim=(-1, 1), ylim=(-S.Pi, S.Pi))
+    p._backend.close()
+
+    p = plot(eqn, xlim=(-1, 1), ylim=(sympify('-3.14'), sympify('3.14')))
+    p._backend.close()
+
+    p = plot(eqn, xlim=(sympify('-3.14'), sympify('3.14')), ylim=(-1, 1))
+    p._backend.close()
+
+    raises(ValueError,
+        lambda: plot(eqn, xlim=(-S.ImaginaryUnit, 1), ylim=(-1, 1)))
+
+    raises(ValueError,
+        lambda: plot(eqn, xlim=(-1, 1), ylim=(-1, S.ImaginaryUnit)))
+
+    raises(ValueError,
+        lambda: plot(eqn, xlim=(S.NegativeInfinity, 1), ylim=(-1, 1)))
+
+    raises(ValueError,
+        lambda: plot(eqn, xlim=(-1, 1), ylim=(-1, S.Infinity)))
+
+
+def test_empty_Plot():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    # No exception showing an empty plot
+    plot()
+    p = Plot()
+    p.show()
+
+
+def test_issue_17405():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    f = x**0.3 - 10*x**3 + x**2
+    p = plot(f, (x, -10, 10), show=False)
+    # Random number of segments, probably more than 100, but we want to see
+    # that there are segments generated, as opposed to when the bug was present
+
+    # RuntimeWarning: invalid value encountered in double_scalars
+    with ignore_warnings(RuntimeWarning):
+        assert len(p[0].get_data()[0]) >= 30
+
+
+def test_logplot_PR_16796():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    p = plot(x, (x, .001, 100), xscale='log', show=False)
+    # Random number of segments, probably more than 100, but we want to see
+    # that there are segments generated, as opposed to when the bug was present
+    assert len(p[0].get_data()[0]) >= 30
+    assert p[0].end == 100.0
+    assert p[0].start == .001
+
+
+def test_issue_16572():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    p = plot(LambertW(x), show=False)
+    # Random number of segments, probably more than 50, but we want to see
+    # that there are segments generated, as opposed to when the bug was present
+    assert len(p[0].get_data()[0]) >= 30
+
+
+def test_issue_11865():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    k = Symbol('k', integer=True)
+    f = Piecewise((-I*exp(I*pi*k)/k + I*exp(-I*pi*k)/k, Ne(k, 0)), (2*pi, True))
+    p = plot(f, show=False)
+    # Random number of segments, probably more than 100, but we want to see
+    # that there are segments generated, as opposed to when the bug was present
+    # and that there are no exceptions.
+    assert len(p[0].get_data()[0]) >= 30
+
+
+def test_issue_11461():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    p = plot(real_root((log(x/(x-2))), 3), show=False)
+    # Random number of segments, probably more than 100, but we want to see
+    # that there are segments generated, as opposed to when the bug was present
+    # and that there are no exceptions.
+    assert len(p[0].get_data()[0]) >= 30
+
+
+def test_issue_11764():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    p = plot_parametric(cos(x), sin(x), (x, 0, 2 * pi), aspect_ratio=(1,1), show=False)
+    assert p.aspect_ratio == (1, 1)
+    # Random number of segments, probably more than 100, but we want to see
+    # that there are segments generated, as opposed to when the bug was present
+    assert len(p[0].get_data()[0]) >= 30
+
+
+def test_issue_13516():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+
+    pm = plot(sin(x), backend="matplotlib", show=False)
+    assert pm.backend == MatplotlibBackend
+    assert len(pm[0].get_data()[0]) >= 30
+
+    pt = plot(sin(x), backend="text", show=False)
+    assert pt.backend == TextBackend
+    assert len(pt[0].get_data()[0]) >= 30
+
+    pd = plot(sin(x), backend="default", show=False)
+    assert pd.backend == DefaultBackend
+    assert len(pd[0].get_data()[0]) >= 30
+
+    p = plot(sin(x), show=False)
+    assert p.backend == DefaultBackend
+    assert len(p[0].get_data()[0]) >= 30
+
+
+def test_plot_limits():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    p = plot(x, x**2, (x, -10, 10))
+    backend = p._backend
+
+    xmin, xmax = backend.ax[0].get_xlim()
+    assert abs(xmin + 10) < 2
+    assert abs(xmax - 10) < 2
+    ymin, ymax = backend.ax[0].get_ylim()
+    assert abs(ymin + 10) < 10
+    assert abs(ymax - 100) < 10
+
+
+def test_plot3d_parametric_line_limits():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+
+    v1 = (2*cos(x), 2*sin(x), 2*x, (x, -5, 5))
+    v2 = (sin(x), cos(x), x, (x, -5, 5))
+    p = plot3d_parametric_line(v1, v2)
+    backend = p._backend
+
+    xmin, xmax = backend.ax[0].get_xlim()
+    assert abs(xmin + 2) < 1e-2
+    assert abs(xmax - 2) < 1e-2
+    ymin, ymax = backend.ax[0].get_ylim()
+    assert abs(ymin + 2) < 1e-2
+    assert abs(ymax - 2) < 1e-2
+    zmin, zmax = backend.ax[0].get_zlim()
+    assert abs(zmin + 10) < 1e-2
+    assert abs(zmax - 10) < 1e-2
+
+    p = plot3d_parametric_line(v2, v1)
+    backend = p._backend
+
+    xmin, xmax = backend.ax[0].get_xlim()
+    assert abs(xmin + 2) < 1e-2
+    assert abs(xmax - 2) < 1e-2
+    ymin, ymax = backend.ax[0].get_ylim()
+    assert abs(ymin + 2) < 1e-2
+    assert abs(ymax - 2) < 1e-2
+    zmin, zmax = backend.ax[0].get_zlim()
+    assert abs(zmin + 10) < 1e-2
+    assert abs(zmax - 10) < 1e-2
+
+def test_plot_size():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+
+    p1 = plot(sin(x), backend="matplotlib", size=(8, 4))
+    s1 = p1._backend.fig.get_size_inches()
+    assert (s1[0] == 8) and (s1[1] == 4)
+    p2 = plot(sin(x), backend="matplotlib", size=(5, 10))
+    s2 = p2._backend.fig.get_size_inches()
+    assert (s2[0] == 5) and (s2[1] == 10)
+    p3 = PlotGrid(2, 1, p1, p2, size=(6, 2))
+    s3 = p3._backend.fig.get_size_inches()
+    assert (s3[0] == 6) and (s3[1] == 2)
+
+    with raises(ValueError):
+        plot(sin(x), backend="matplotlib", size=(-1, 3))
+
+def test_issue_20113():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+
+    # verify the capability to use custom backends
+    with raises(TypeError):
+        plot(sin(x), backend=Plot, show=False)
+    p2 = plot(sin(x), backend=MatplotlibBackend, show=False)
+    assert p2.backend == MatplotlibBackend
+    assert len(p2[0].get_data()[0]) >= 30
+    p3 = plot(sin(x), backend=DummyBackendOk, show=False)
+    assert p3.backend == DummyBackendOk
+    assert len(p3[0].get_data()[0]) >= 30
+
+    # test for an improper coded backend
+    p4 = plot(sin(x), backend=DummyBackendNotOk, show=False)
+    assert p4.backend == DummyBackendNotOk
+    assert len(p4[0].get_data()[0]) >= 30
+    with raises(NotImplementedError):
+        p4.show()
+    with raises(NotImplementedError):
+        p4.save("test/path")
+    with raises(NotImplementedError):
+        p4._backend.close()
+
+def test_custom_coloring():
+    x = Symbol('x')
+    y = Symbol('y')
+    plot(cos(x), line_color=lambda a: a)
+    plot(cos(x), line_color=1)
+    plot(cos(x), line_color="r")
+    plot_parametric(cos(x), sin(x), line_color=lambda a: a)
+    plot_parametric(cos(x), sin(x), line_color=1)
+    plot_parametric(cos(x), sin(x), line_color="r")
+    plot3d_parametric_line(cos(x), sin(x), x, line_color=lambda a: a)
+    plot3d_parametric_line(cos(x), sin(x), x, line_color=1)
+    plot3d_parametric_line(cos(x), sin(x), x, line_color="r")
+    plot3d_parametric_surface(cos(x + y), sin(x - y), x - y,
+            (x, -5, 5), (y, -5, 5),
+            surface_color=lambda a, b: a**2 + b**2)
+    plot3d_parametric_surface(cos(x + y), sin(x - y), x - y,
+            (x, -5, 5), (y, -5, 5),
+            surface_color=1)
+    plot3d_parametric_surface(cos(x + y), sin(x - y), x - y,
+            (x, -5, 5), (y, -5, 5),
+            surface_color="r")
+    plot3d(x*y, (x, -5, 5), (y, -5, 5),
+            surface_color=lambda a, b: a**2 + b**2)
+    plot3d(x*y, (x, -5, 5), (y, -5, 5), surface_color=1)
+    plot3d(x*y, (x, -5, 5), (y, -5, 5), surface_color="r")
+
+def test_deprecated_get_segments():
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    x = Symbol('x')
+    f = sin(x)
+    p = plot(f, (x, -10, 10), show=False)
+    with warns_deprecated_sympy():
+        p[0].get_segments()

venv/lib/python3.10/site-packages/sympy/plotting/tests/test_plot_implicit.py

@@ -0,0 +1,146 @@
+from sympy.core.numbers import (I, pi)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import re
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+from sympy.logic.boolalg import (And, Or)
+from sympy.plotting.plot_implicit import plot_implicit
+from sympy.plotting.plot import unset_show
+from tempfile import NamedTemporaryFile, mkdtemp
+from sympy.testing.pytest import skip, warns, XFAIL
+from sympy.external import import_module
+from sympy.testing.tmpfiles import TmpFileManager
+
+import os
+
+#Set plots not to show
+unset_show()
+
+def tmp_file(dir=None, name=''):
+    return NamedTemporaryFile(
+    suffix='.png', dir=dir, delete=False).name
+
+def plot_and_save(expr, *args, name='', dir=None, **kwargs):
+    p = plot_implicit(expr, *args, **kwargs)
+    p.save(tmp_file(dir=dir, name=name))
+    # Close the plot to avoid a warning from matplotlib
+    p._backend.close()
+
+def plot_implicit_tests(name):
+    temp_dir = mkdtemp()
+    TmpFileManager.tmp_folder(temp_dir)
+    x = Symbol('x')
+    y = Symbol('y')
+    #implicit plot tests
+    plot_and_save(Eq(y, cos(x)), (x, -5, 5), (y, -2, 2), name=name, dir=temp_dir)
+    plot_and_save(Eq(y**2, x**3 - x), (x, -5, 5),
+            (y, -4, 4), name=name, dir=temp_dir)
+    plot_and_save(y > 1 / x, (x, -5, 5),
+            (y, -2, 2), name=name, dir=temp_dir)
+    plot_and_save(y < 1 / tan(x), (x, -5, 5),
+            (y, -2, 2), name=name, dir=temp_dir)
+    plot_and_save(y >= 2 * sin(x) * cos(x), (x, -5, 5),
+            (y, -2, 2), name=name, dir=temp_dir)
+    plot_and_save(y <= x**2, (x, -3, 3),
+            (y, -1, 5), name=name, dir=temp_dir)
+
+    #Test all input args for plot_implicit
+    plot_and_save(Eq(y**2, x**3 - x), dir=temp_dir)
+    plot_and_save(Eq(y**2, x**3 - x), adaptive=False, dir=temp_dir)
+    plot_and_save(Eq(y**2, x**3 - x), adaptive=False, points=500, dir=temp_dir)
+    plot_and_save(y > x, (x, -5, 5), dir=temp_dir)
+    plot_and_save(And(y > exp(x), y > x + 2), dir=temp_dir)
+    plot_and_save(Or(y > x, y > -x), dir=temp_dir)
+    plot_and_save(x**2 - 1, (x, -5, 5), dir=temp_dir)
+    plot_and_save(x**2 - 1, dir=temp_dir)
+    plot_and_save(y > x, depth=-5, dir=temp_dir)
+    plot_and_save(y > x, depth=5, dir=temp_dir)
+    plot_and_save(y > cos(x), adaptive=False, dir=temp_dir)
+    plot_and_save(y < cos(x), adaptive=False, dir=temp_dir)
+    plot_and_save(And(y > cos(x), Or(y > x, Eq(y, x))), dir=temp_dir)
+    plot_and_save(y - cos(pi / x), dir=temp_dir)
+
+    plot_and_save(x**2 - 1, title='An implicit plot', dir=temp_dir)
+
+@XFAIL
+def test_no_adaptive_meshing():
+    matplotlib = import_module('matplotlib', min_module_version='1.1.0', catch=(RuntimeError,))
+    if matplotlib:
+        try:
+            temp_dir = mkdtemp()
+            TmpFileManager.tmp_folder(temp_dir)
+            x = Symbol('x')
+            y = Symbol('y')
+            # Test plots which cannot be rendered using the adaptive algorithm
+
+            # This works, but it triggers a deprecation warning from sympify(). The
+            # code needs to be updated to detect if interval math is supported without
+            # relying on random AttributeErrors.
+            with warns(UserWarning, match="Adaptive meshing could not be applied"):
+                plot_and_save(Eq(y, re(cos(x) + I*sin(x))), name='test', dir=temp_dir)
+        finally:
+            TmpFileManager.cleanup()
+    else:
+        skip("Matplotlib not the default backend")
+def test_line_color():
+    x, y = symbols('x, y')
+    p = plot_implicit(x**2 + y**2 - 1, line_color="green", show=False)
+    assert p._series[0].line_color == "green"
+    p = plot_implicit(x**2 + y**2 - 1, line_color='r', show=False)
+    assert p._series[0].line_color == "r"
+
+def test_matplotlib():
+    matplotlib = import_module('matplotlib', min_module_version='1.1.0', catch=(RuntimeError,))
+    if matplotlib:
+        try:
+            plot_implicit_tests('test')
+            test_line_color()
+        finally:
+            TmpFileManager.cleanup()
+    else:
+        skip("Matplotlib not the default backend")
+
+
+def test_region_and():
+    matplotlib = import_module('matplotlib', min_module_version='1.1.0', catch=(RuntimeError,))
+    if not matplotlib:
+        skip("Matplotlib not the default backend")
+
+    from matplotlib.testing.compare import compare_images
+    test_directory = os.path.dirname(os.path.abspath(__file__))
+
+    try:
+        temp_dir = mkdtemp()
+        TmpFileManager.tmp_folder(temp_dir)
+
+        x, y = symbols('x y')
+
+        r1 = (x - 1)**2 + y**2 < 2
+        r2 = (x + 1)**2 + y**2 < 2
+
+        test_filename = tmp_file(dir=temp_dir, name="test_region_and")
+        cmp_filename = os.path.join(test_directory, "test_region_and.png")
+        p = plot_implicit(r1 & r2, x, y)
+        p.save(test_filename)
+        compare_images(cmp_filename, test_filename, 0.005)
+
+        test_filename = tmp_file(dir=temp_dir, name="test_region_or")
+        cmp_filename = os.path.join(test_directory, "test_region_or.png")
+        p = plot_implicit(r1 | r2, x, y)
+        p.save(test_filename)
+        compare_images(cmp_filename, test_filename, 0.005)
+
+        test_filename = tmp_file(dir=temp_dir, name="test_region_not")
+        cmp_filename = os.path.join(test_directory, "test_region_not.png")
+        p = plot_implicit(~r1, x, y)
+        p.save(test_filename)
+        compare_images(cmp_filename, test_filename, 0.005)
+
+        test_filename = tmp_file(dir=temp_dir, name="test_region_xor")
+        cmp_filename = os.path.join(test_directory, "test_region_xor.png")
+        p = plot_implicit(r1 ^ r2, x, y)
+        p.save(test_filename)
+        compare_images(cmp_filename, test_filename, 0.005)
+    finally:
+        TmpFileManager.cleanup()

venv/lib/python3.10/site-packages/sympy/plotting/tests/test_textplot.py

@@ -0,0 +1,203 @@
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.plotting.textplot import textplot_str
+
+from sympy.utilities.exceptions import ignore_warnings
+
+
+def test_axes_alignment():
+    x = Symbol('x')
+    lines = [
+        '      1 |                                                     ..',
+        '        |                                                  ...  ',
+        '        |                                                ..     ',
+        '        |                                             ...       ',
+        '        |                                          ...          ',
+        '        |                                        ..             ',
+        '        |                                     ...               ',
+        '        |                                  ...                  ',
+        '        |                                ..                     ',
+        '        |                             ...                       ',
+        '      0 |--------------------------...--------------------------',
+        '        |                       ...                             ',
+        '        |                     ..                                ',
+        '        |                  ...                                  ',
+        '        |               ...                                     ',
+        '        |             ..                                        ',
+        '        |          ...                                          ',
+        '        |       ...                                             ',
+        '        |     ..                                                ',
+        '        |  ...                                                  ',
+        '     -1 |_______________________________________________________',
+        '         -1                         0                          1'
+    ]
+    assert lines == list(textplot_str(x, -1, 1))
+
+    lines = [
+        '      1 |                                                     ..',
+        '        |                                                 ....  ',
+        '        |                                              ...      ',
+        '        |                                           ...         ',
+        '        |                                       ....            ',
+        '        |                                    ...                ',
+        '        |                                 ...                   ',
+        '        |                             ....                      ',
+        '      0 |--------------------------...--------------------------',
+        '        |                      ....                             ',
+        '        |                   ...                                 ',
+        '        |                ...                                    ',
+        '        |            ....                                       ',
+        '        |         ...                                           ',
+        '        |      ...                                              ',
+        '        |  ....                                                 ',
+        '     -1 |_______________________________________________________',
+        '         -1                         0                          1'
+    ]
+    assert lines == list(textplot_str(x, -1, 1, H=17))
+
+
+def test_singularity():
+    x = Symbol('x')
+    lines = [
+        '     54 | .                                                     ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ','        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '   27.5 |--.----------------------------------------------------',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |   .                                                   ',
+        '        |    \\                                                  ',
+        '        |     \\                                                 ',
+        '        |      ..                                               ',
+        '        |        ...                                            ',
+        '        |           .............                               ',
+        '      1 |_______________________________________________________',
+        '         0                          0.5                        1'
+    ]
+    assert lines == list(textplot_str(1/x, 0, 1))
+
+    lines = [
+        '      0 |                                                 ......',
+        '        |                                         ........      ',
+        '        |                                 ........              ',
+        '        |                           ......                      ',
+        '        |                      .....                            ',
+        '        |                  ....                                 ',
+        '        |               ...                                     ',
+        '        |             ..                                        ',
+        '        |          ...                                          ',
+        '        |         /                                             ',
+        '     -2 |-------..----------------------------------------------',
+        '        |      /                                                ',
+        '        |     /                                                 ',
+        '        |    /                                                  ',
+        '        |   .                                                   ',
+        '        |                                                       ',
+        '        |  .                                                    ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '     -4 |_______________________________________________________',
+        '         0                          0.5                        1'
+    ]
+    # RuntimeWarning: divide by zero encountered in log
+    with ignore_warnings(RuntimeWarning):
+        assert lines == list(textplot_str(log(x), 0, 1))
+
+
+def test_sinc():
+    x = Symbol('x')
+    lines = [
+        '      1 |                          . .                          ',
+        '        |                         .   .                         ',
+        '        |                                                       ',
+        '        |                        .     .                        ',
+        '        |                                                       ',
+        '        |                       .       .                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                      .         .                      ',
+        '        |                                                       ',
+        '    0.4 |-------------------------------------------------------',
+        '        |                     .           .                     ',
+        '        |                                                       ',
+        '        |                    .             .                    ',
+        '        |                                                       ',
+        '        |    .....                                     .....    ',
+        '        |  ..     \\         .               .         /     ..  ',
+        '        | /        \\                                 /        \\ ',
+        '        |/          \\      .                 .      /          \\',
+        '        |            \\    /                   \\    /            ',
+        '   -0.2 |_______________________________________________________',
+        '         -10                        0                          10'
+    ]
+    # RuntimeWarning: invalid value encountered in double_scalars
+    with ignore_warnings(RuntimeWarning):
+        assert lines == list(textplot_str(sin(x)/x, -10, 10))
+
+
+def test_imaginary():
+    x = Symbol('x')
+    lines = [
+        '      1 |                                                     ..',
+        '        |                                                   ..  ',
+        '        |                                                ...    ',
+        '        |                                              ..       ',
+        '        |                                            ..         ',
+        '        |                                          ..           ',
+        '        |                                        ..             ',
+        '        |                                      ..               ',
+        '        |                                    ..                 ',
+        '        |                                   /                   ',
+        '    0.5 |----------------------------------/--------------------',
+        '        |                                ..                     ',
+        '        |                               /                       ',
+        '        |                              .                        ',
+        '        |                                                       ',
+        '        |                             .                         ',
+        '        |                            .                          ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '      0 |_______________________________________________________',
+        '         -1                         0                          1'
+    ]
+    # RuntimeWarning: invalid value encountered in sqrt
+    with ignore_warnings(RuntimeWarning):
+        assert list(textplot_str(sqrt(x), -1, 1)) == lines
+
+    lines = [
+        '      1 |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '      0 |-------------------------------------------------------',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '        |                                                       ',
+        '     -1 |_______________________________________________________',
+        '         -1                         0                          1'
+    ]
+    assert list(textplot_str(S.ImaginaryUnit, -1, 1)) == lines

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

@@ -0,0 +1,60 @@
+"""The module helps converting SymPy expressions into shorter forms of them.
+
+for example:
+the expression E**(pi*I) will be converted into -1
+the expression (x+x)**2 will be converted into 4*x**2
+"""
+from .simplify import (simplify, hypersimp, hypersimilar,
+    logcombine, separatevars, posify, besselsimp, kroneckersimp,
+    signsimp, nsimplify)
+
+from .fu import FU, fu
+
+from .sqrtdenest import sqrtdenest
+
+from .cse_main import cse
+
+from .epathtools import epath, EPath
+
+from .hyperexpand import hyperexpand
+
+from .radsimp import collect, rcollect, radsimp, collect_const, fraction, numer, denom
+
+from .trigsimp import trigsimp, exptrigsimp
+
+from .powsimp import powsimp, powdenest
+
+from .combsimp import combsimp
+
+from .gammasimp import gammasimp
+
+from .ratsimp import ratsimp, ratsimpmodprime
+
+__all__ = [
+    'simplify', 'hypersimp', 'hypersimilar', 'logcombine', 'separatevars',
+    'posify', 'besselsimp', 'kroneckersimp', 'signsimp',
+    'nsimplify',
+
+    'FU', 'fu',
+
+    'sqrtdenest',
+
+    'cse',
+
+    'epath', 'EPath',
+
+    'hyperexpand',
+
+    'collect', 'rcollect', 'radsimp', 'collect_const', 'fraction', 'numer',
+    'denom',
+
+    'trigsimp', 'exptrigsimp',
+
+    'powsimp', 'powdenest',
+
+    'combsimp',
+
+    'gammasimp',
+
+    'ratsimp', 'ratsimpmodprime',
+]

venv/lib/python3.10/site-packages/sympy/simplify/combsimp.py

@@ -0,0 +1,114 @@
+from sympy.core import Mul
+from sympy.core.function import count_ops
+from sympy.core.traversal import preorder_traversal, bottom_up
+from sympy.functions.combinatorial.factorials import binomial, factorial
+from sympy.functions import gamma
+from sympy.simplify.gammasimp import gammasimp, _gammasimp
+
+from sympy.utilities.timeutils import timethis
+
+
+@timethis('combsimp')
+def combsimp(expr):
+    r"""
+    Simplify combinatorial expressions.
+
+    Explanation
+    ===========
+
+    This function takes as input an expression containing factorials,
+    binomials, Pochhammer symbol and other "combinatorial" functions,
+    and tries to minimize the number of those functions and reduce
+    the size of their arguments.
+
+    The algorithm works by rewriting all combinatorial functions as
+    gamma functions and applying gammasimp() except simplification
+    steps that may make an integer argument non-integer. See docstring
+    of gammasimp for more information.
+
+    Then it rewrites expression in terms of factorials and binomials by
+    rewriting gammas as factorials and converting (a+b)!/a!b! into
+    binomials.
+
+    If expression has gamma functions or combinatorial functions
+    with non-integer argument, it is automatically passed to gammasimp.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify import combsimp
+    >>> from sympy import factorial, binomial, symbols
+    >>> n, k = symbols('n k', integer = True)
+
+    >>> combsimp(factorial(n)/factorial(n - 3))
+    n*(n - 2)*(n - 1)
+    >>> combsimp(binomial(n+1, k+1)/binomial(n, k))
+    (n + 1)/(k + 1)
+
+    """
+
+    expr = expr.rewrite(gamma, piecewise=False)
+    if any(isinstance(node, gamma) and not node.args[0].is_integer
+        for node in preorder_traversal(expr)):
+        return gammasimp(expr);
+
+    expr = _gammasimp(expr, as_comb = True)
+    expr = _gamma_as_comb(expr)
+    return expr
+
+
+def _gamma_as_comb(expr):
+    """
+    Helper function for combsimp.
+
+    Rewrites expression in terms of factorials and binomials
+    """
+
+    expr = expr.rewrite(factorial)
+
+    def f(rv):
+        if not rv.is_Mul:
+            return rv
+        rvd = rv.as_powers_dict()
+        nd_fact_args = [[], []] # numerator, denominator
+
+        for k in rvd:
+            if isinstance(k, factorial) and rvd[k].is_Integer:
+                if rvd[k].is_positive:
+                    nd_fact_args[0].extend([k.args[0]]*rvd[k])
+                else:
+                    nd_fact_args[1].extend([k.args[0]]*-rvd[k])
+                rvd[k] = 0
+        if not nd_fact_args[0] or not nd_fact_args[1]:
+            return rv
+
+        hit = False
+        for m in range(2):
+            i = 0
+            while i < len(nd_fact_args[m]):
+                ai = nd_fact_args[m][i]
+                for j in range(i + 1, len(nd_fact_args[m])):
+                    aj = nd_fact_args[m][j]
+
+                    sum = ai + aj
+                    if sum in nd_fact_args[1 - m]:
+                        hit = True
+
+                        nd_fact_args[1 - m].remove(sum)
+                        del nd_fact_args[m][j]
+                        del nd_fact_args[m][i]
+
+                        rvd[binomial(sum, ai if count_ops(ai) <
+                                count_ops(aj) else aj)] += (
+                                -1 if m == 0 else 1)
+                        break
+                else:
+                    i += 1
+
+        if hit:
+            return Mul(*([k**rvd[k] for k in rvd] + [factorial(k)
+                    for k in nd_fact_args[0]]))/Mul(*[factorial(k)
+                    for k in nd_fact_args[1]])
+        return rv
+
+    return bottom_up(expr, f)

venv/lib/python3.10/site-packages/sympy/simplify/cse_main.py

@@ -0,0 +1,946 @@
+""" Tools for doing common subexpression elimination.
+"""
+from collections import defaultdict
+
+from sympy.core import Basic, Mul, Add, Pow, sympify
+from sympy.core.containers import Tuple, OrderedSet
+from sympy.core.exprtools import factor_terms
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import symbols, Symbol
+from sympy.matrices import (MatrixBase, Matrix, ImmutableMatrix,
+                            SparseMatrix, ImmutableSparseMatrix)
+from sympy.matrices.expressions import (MatrixExpr, MatrixSymbol, MatMul,
+                                        MatAdd, MatPow, Inverse)
+from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.polys.rootoftools import RootOf
+from sympy.utilities.iterables import numbered_symbols, sift, \
+        topological_sort, iterable
+
+from . import cse_opts
+
+# (preprocessor, postprocessor) pairs which are commonly useful. They should
+# each take a SymPy expression and return a possibly transformed expression.
+# When used in the function ``cse()``, the target expressions will be transformed
+# by each of the preprocessor functions in order. After the common
+# subexpressions are eliminated, each resulting expression will have the
+# postprocessor functions transform them in *reverse* order in order to undo the
+# transformation if necessary. This allows the algorithm to operate on
+# a representation of the expressions that allows for more optimization
+# opportunities.
+# ``None`` can be used to specify no transformation for either the preprocessor or
+# postprocessor.
+
+
+basic_optimizations = [(cse_opts.sub_pre, cse_opts.sub_post),
+                       (factor_terms, None)]
+
+# sometimes we want the output in a different format; non-trivial
+# transformations can be put here for users
+# ===============================================================
+
+
+def reps_toposort(r):
+    """Sort replacements ``r`` so (k1, v1) appears before (k2, v2)
+    if k2 is in v1's free symbols. This orders items in the
+    way that cse returns its results (hence, in order to use the
+    replacements in a substitution option it would make sense
+    to reverse the order).
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.cse_main import reps_toposort
+    >>> from sympy.abc import x, y
+    >>> from sympy import Eq
+    >>> for l, r in reps_toposort([(x, y + 1), (y, 2)]):
+    ...     print(Eq(l, r))
+    ...
+    Eq(y, 2)
+    Eq(x, y + 1)
+
+    """
+    r = sympify(r)
+    E = []
+    for c1, (k1, v1) in enumerate(r):
+        for c2, (k2, v2) in enumerate(r):
+            if k1 in v2.free_symbols:
+                E.append((c1, c2))
+    return [r[i] for i in topological_sort((range(len(r)), E))]
+
+
+def cse_separate(r, e):
+    """Move expressions that are in the form (symbol, expr) out of the
+    expressions and sort them into the replacements using the reps_toposort.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.cse_main import cse_separate
+    >>> from sympy.abc import x, y, z
+    >>> from sympy import cos, exp, cse, Eq, symbols
+    >>> x0, x1 = symbols('x:2')
+    >>> eq = (x + 1 + exp((x + 1)/(y + 1)) + cos(y + 1))
+    >>> cse([eq, Eq(x, z + 1), z - 2], postprocess=cse_separate) in [
+    ... [[(x0, y + 1), (x, z + 1), (x1, x + 1)],
+    ...  [x1 + exp(x1/x0) + cos(x0), z - 2]],
+    ... [[(x1, y + 1), (x, z + 1), (x0, x + 1)],
+    ...  [x0 + exp(x0/x1) + cos(x1), z - 2]]]
+    ...
+    True
+    """
+    d = sift(e, lambda w: w.is_Equality and w.lhs.is_Symbol)
+    r = r + [w.args for w in d[True]]
+    e = d[False]
+    return [reps_toposort(r), e]
+
+
+def cse_release_variables(r, e):
+    """
+    Return tuples giving ``(a, b)`` where ``a`` is a symbol and ``b`` is
+    either an expression or None. The value of None is used when a
+    symbol is no longer needed for subsequent expressions.
+
+    Use of such output can reduce the memory footprint of lambdified
+    expressions that contain large, repeated subexpressions.
+
+    Examples
+    ========
+
+    >>> from sympy import cse
+    >>> from sympy.simplify.cse_main import cse_release_variables
+    >>> from sympy.abc import x, y
+    >>> eqs = [(x + y - 1)**2, x, x + y, (x + y)/(2*x + 1) + (x + y - 1)**2, (2*x + 1)**(x + y)]
+    >>> defs, rvs = cse_release_variables(*cse(eqs))
+    >>> for i in defs:
+    ...   print(i)
+    ...
+    (x0, x + y)
+    (x1, (x0 - 1)**2)
+    (x2, 2*x + 1)
+    (_3, x0/x2 + x1)
+    (_4, x2**x0)
+    (x2, None)
+    (_0, x1)
+    (x1, None)
+    (_2, x0)
+    (x0, None)
+    (_1, x)
+    >>> print(rvs)
+    (_0, _1, _2, _3, _4)
+    """
+    if not r:
+        return r, e
+
+    s, p = zip(*r)
+    esyms = symbols('_:%d' % len(e))
+    syms = list(esyms)
+    s = list(s)
+    in_use = set(s)
+    p = list(p)
+    # sort e so those with most sub-expressions appear first
+    e = [(e[i], syms[i]) for i in range(len(e))]
+    e, syms = zip(*sorted(e,
+        key=lambda x: -sum([p[s.index(i)].count_ops()
+        for i in x[0].free_symbols & in_use])))
+    syms = list(syms)
+    p += e
+    rv = []
+    i = len(p) - 1
+    while i >= 0:
+        _p = p.pop()
+        c = in_use & _p.free_symbols
+        if c: # sorting for canonical results
+            rv.extend([(s, None) for s in sorted(c, key=str)])
+        if i >= len(r):
+            rv.append((syms.pop(), _p))
+        else:
+            rv.append((s[i], _p))
+        in_use -= c
+        i -= 1
+    rv.reverse()
+    return rv, esyms
+
+
+# ====end of cse postprocess idioms===========================
+
+
+def preprocess_for_cse(expr, optimizations):
+    """ Preprocess an expression to optimize for common subexpression
+    elimination.
+
+    Parameters
+    ==========
+
+    expr : SymPy expression
+        The target expression to optimize.
+    optimizations : list of (callable, callable) pairs
+        The (preprocessor, postprocessor) pairs.
+
+    Returns
+    =======
+
+    expr : SymPy expression
+        The transformed expression.
+    """
+    for pre, post in optimizations:
+        if pre is not None:
+            expr = pre(expr)
+    return expr
+
+
+def postprocess_for_cse(expr, optimizations):
+    """Postprocess an expression after common subexpression elimination to
+    return the expression to canonical SymPy form.
+
+    Parameters
+    ==========
+
+    expr : SymPy expression
+        The target expression to transform.
+    optimizations : list of (callable, callable) pairs, optional
+        The (preprocessor, postprocessor) pairs.  The postprocessors will be
+        applied in reversed order to undo the effects of the preprocessors
+        correctly.
+
+    Returns
+    =======
+
+    expr : SymPy expression
+        The transformed expression.
+    """
+    for pre, post in reversed(optimizations):
+        if post is not None:
+            expr = post(expr)
+    return expr
+
+
+class FuncArgTracker:
+    """
+    A class which manages a mapping from functions to arguments and an inverse
+    mapping from arguments to functions.
+    """
+
+    def __init__(self, funcs):
+        # To minimize the number of symbolic comparisons, all function arguments
+        # get assigned a value number.
+        self.value_numbers = {}
+        self.value_number_to_value = []
+
+        # Both of these maps use integer indices for arguments / functions.
+        self.arg_to_funcset = []
+        self.func_to_argset = []
+
+        for func_i, func in enumerate(funcs):
+            func_argset = OrderedSet()
+
+            for func_arg in func.args:
+                arg_number = self.get_or_add_value_number(func_arg)
+                func_argset.add(arg_number)
+                self.arg_to_funcset[arg_number].add(func_i)
+
+            self.func_to_argset.append(func_argset)
+
+    def get_args_in_value_order(self, argset):
+        """
+        Return the list of arguments in sorted order according to their value
+        numbers.
+        """
+        return [self.value_number_to_value[argn] for argn in sorted(argset)]
+
+    def get_or_add_value_number(self, value):
+        """
+        Return the value number for the given argument.
+        """
+        nvalues = len(self.value_numbers)
+        value_number = self.value_numbers.setdefault(value, nvalues)
+        if value_number == nvalues:
+            self.value_number_to_value.append(value)
+            self.arg_to_funcset.append(OrderedSet())
+        return value_number
+
+    def stop_arg_tracking(self, func_i):
+        """
+        Remove the function func_i from the argument to function mapping.
+        """
+        for arg in self.func_to_argset[func_i]:
+            self.arg_to_funcset[arg].remove(func_i)
+
+
+    def get_common_arg_candidates(self, argset, min_func_i=0):
+        """Return a dict whose keys are function numbers. The entries of the dict are
+        the number of arguments said function has in common with
+        ``argset``. Entries have at least 2 items in common.  All keys have
+        value at least ``min_func_i``.
+        """
+        count_map = defaultdict(lambda: 0)
+        if not argset:
+            return count_map
+
+        funcsets = [self.arg_to_funcset[arg] for arg in argset]
+        # As an optimization below, we handle the largest funcset separately from
+        # the others.
+        largest_funcset = max(funcsets, key=len)
+
+        for funcset in funcsets:
+            if largest_funcset is funcset:
+                continue
+            for func_i in funcset:
+                if func_i >= min_func_i:
+                    count_map[func_i] += 1
+
+        # We pick the smaller of the two containers (count_map, largest_funcset)
+        # to iterate over to reduce the number of iterations needed.
+        (smaller_funcs_container,
+         larger_funcs_container) = sorted(
+                 [largest_funcset, count_map],
+                 key=len)
+
+        for func_i in smaller_funcs_container:
+            # Not already in count_map? It can't possibly be in the output, so
+            # skip it.
+            if count_map[func_i] < 1:
+                continue
+
+            if func_i in larger_funcs_container:
+                count_map[func_i] += 1
+
+        return {k: v for k, v in count_map.items() if v >= 2}
+
+    def get_subset_candidates(self, argset, restrict_to_funcset=None):
+        """
+        Return a set of functions each of which whose argument list contains
+        ``argset``, optionally filtered only to contain functions in
+        ``restrict_to_funcset``.
+        """
+        iarg = iter(argset)
+
+        indices = OrderedSet(
+            fi for fi in self.arg_to_funcset[next(iarg)])
+
+        if restrict_to_funcset is not None:
+            indices &= restrict_to_funcset
+
+        for arg in iarg:
+            indices &= self.arg_to_funcset[arg]
+
+        return indices
+
+    def update_func_argset(self, func_i, new_argset):
+        """
+        Update a function with a new set of arguments.
+        """
+        new_args = OrderedSet(new_argset)
+        old_args = self.func_to_argset[func_i]
+
+        for deleted_arg in old_args - new_args:
+            self.arg_to_funcset[deleted_arg].remove(func_i)
+        for added_arg in new_args - old_args:
+            self.arg_to_funcset[added_arg].add(func_i)
+
+        self.func_to_argset[func_i].clear()
+        self.func_to_argset[func_i].update(new_args)
+
+
+class Unevaluated:
+
+    def __init__(self, func, args):
+        self.func = func
+        self.args = args
+
+    def __str__(self):
+        return "Uneval<{}>({})".format(
+                self.func, ", ".join(str(a) for a in self.args))
+
+    def as_unevaluated_basic(self):
+        return self.func(*self.args, evaluate=False)
+
+    @property
+    def free_symbols(self):
+        return set().union(*[a.free_symbols for a in self.args])
+
+    __repr__ = __str__
+
+
+def match_common_args(func_class, funcs, opt_subs):
+    """
+    Recognize and extract common subexpressions of function arguments within a
+    set of function calls. For instance, for the following function calls::
+
+        x + z + y
+        sin(x + y)
+
+    this will extract a common subexpression of `x + y`::
+
+        w = x + y
+        w + z
+        sin(w)
+
+    The function we work with is assumed to be associative and commutative.
+
+    Parameters
+    ==========
+
+    func_class: class
+        The function class (e.g. Add, Mul)
+    funcs: list of functions
+        A list of function calls.
+    opt_subs: dict
+        A dictionary of substitutions which this function may update.
+    """
+
+    # Sort to ensure that whole-function subexpressions come before the items
+    # that use them.
+    funcs = sorted(funcs, key=lambda f: len(f.args))
+    arg_tracker = FuncArgTracker(funcs)
+
+    changed = OrderedSet()
+
+    for i in range(len(funcs)):
+        common_arg_candidates_counts = arg_tracker.get_common_arg_candidates(
+                arg_tracker.func_to_argset[i], min_func_i=i + 1)
+
+        # Sort the candidates in order of match size.
+        # This makes us try combining smaller matches first.
+        common_arg_candidates = OrderedSet(sorted(
+                common_arg_candidates_counts.keys(),
+                key=lambda k: (common_arg_candidates_counts[k], k)))
+
+        while common_arg_candidates:
+            j = common_arg_candidates.pop(last=False)
+
+            com_args = arg_tracker.func_to_argset[i].intersection(
+                    arg_tracker.func_to_argset[j])
+
+            if len(com_args) <= 1:
+                # This may happen if a set of common arguments was already
+                # combined in a previous iteration.
+                continue
+
+            # For all sets, replace the common symbols by the function
+            # over them, to allow recursive matches.
+
+            diff_i = arg_tracker.func_to_argset[i].difference(com_args)
+            if diff_i:
+                # com_func needs to be unevaluated to allow for recursive matches.
+                com_func = Unevaluated(
+                        func_class, arg_tracker.get_args_in_value_order(com_args))
+                com_func_number = arg_tracker.get_or_add_value_number(com_func)
+                arg_tracker.update_func_argset(i, diff_i | OrderedSet([com_func_number]))
+                changed.add(i)
+            else:
+                # Treat the whole expression as a CSE.
+                #
+                # The reason this needs to be done is somewhat subtle. Within
+                # tree_cse(), to_eliminate only contains expressions that are
+                # seen more than once. The problem is unevaluated expressions
+                # do not compare equal to the evaluated equivalent. So
+                # tree_cse() won't mark funcs[i] as a CSE if we use an
+                # unevaluated version.
+                com_func_number = arg_tracker.get_or_add_value_number(funcs[i])
+
+            diff_j = arg_tracker.func_to_argset[j].difference(com_args)
+            arg_tracker.update_func_argset(j, diff_j | OrderedSet([com_func_number]))
+            changed.add(j)
+
+            for k in arg_tracker.get_subset_candidates(
+                    com_args, common_arg_candidates):
+                diff_k = arg_tracker.func_to_argset[k].difference(com_args)
+                arg_tracker.update_func_argset(k, diff_k | OrderedSet([com_func_number]))
+                changed.add(k)
+
+        if i in changed:
+            opt_subs[funcs[i]] = Unevaluated(func_class,
+                arg_tracker.get_args_in_value_order(arg_tracker.func_to_argset[i]))
+
+        arg_tracker.stop_arg_tracking(i)
+
+
+def opt_cse(exprs, order='canonical'):
+    """Find optimization opportunities in Adds, Muls, Pows and negative
+    coefficient Muls.
+
+    Parameters
+    ==========
+
+    exprs : list of SymPy expressions
+        The expressions to optimize.
+    order : string, 'none' or 'canonical'
+        The order by which Mul and Add arguments are processed. For large
+        expressions where speed is a concern, use the setting order='none'.
+
+    Returns
+    =======
+
+    opt_subs : dictionary of expression substitutions
+        The expression substitutions which can be useful to optimize CSE.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.cse_main import opt_cse
+    >>> from sympy.abc import x
+    >>> opt_subs = opt_cse([x**-2])
+    >>> k, v = list(opt_subs.keys())[0], list(opt_subs.values())[0]
+    >>> print((k, v.as_unevaluated_basic()))
+    (x**(-2), 1/(x**2))
+    """
+    opt_subs = {}
+
+    adds = OrderedSet()
+    muls = OrderedSet()
+
+    seen_subexp = set()
+    collapsible_subexp = set()
+
+    def _find_opts(expr):
+
+        if not isinstance(expr, (Basic, Unevaluated)):
+            return
+
+        if expr.is_Atom or expr.is_Order:
+            return
+
+        if iterable(expr):
+            list(map(_find_opts, expr))
+            return
+
+        if expr in seen_subexp:
+            return expr
+        seen_subexp.add(expr)
+
+        list(map(_find_opts, expr.args))
+
+        if not isinstance(expr, MatrixExpr) and expr.could_extract_minus_sign():
+            # XXX -expr does not always work rigorously for some expressions
+            # containing UnevaluatedExpr.
+            # https://github.com/sympy/sympy/issues/24818
+            if isinstance(expr, Add):
+                neg_expr = Add(*(-i for i in expr.args))
+            else:
+                neg_expr = -expr
+
+            if not neg_expr.is_Atom:
+                opt_subs[expr] = Unevaluated(Mul, (S.NegativeOne, neg_expr))
+                seen_subexp.add(neg_expr)
+                expr = neg_expr
+
+        if isinstance(expr, (Mul, MatMul)):
+            if len(expr.args) == 1:
+                collapsible_subexp.add(expr)
+            else:
+                muls.add(expr)
+
+        elif isinstance(expr, (Add, MatAdd)):
+            if len(expr.args) == 1:
+                collapsible_subexp.add(expr)
+            else:
+                adds.add(expr)
+
+        elif isinstance(expr, Inverse):
+            # Do not want to treat `Inverse` as a `MatPow`
+            pass
+
+        elif isinstance(expr, (Pow, MatPow)):
+            base, exp = expr.base, expr.exp
+            if exp.could_extract_minus_sign():
+                opt_subs[expr] = Unevaluated(Pow, (Pow(base, -exp), -1))
+
+    for e in exprs:
+        if isinstance(e, (Basic, Unevaluated)):
+            _find_opts(e)
+
+    # Handle collapsing of multinary operations with single arguments
+    edges = [(s, s.args[0]) for s in collapsible_subexp
+             if s.args[0] in collapsible_subexp]
+    for e in reversed(topological_sort((collapsible_subexp, edges))):
+        opt_subs[e] = opt_subs.get(e.args[0], e.args[0])
+
+    # split muls into commutative
+    commutative_muls = OrderedSet()
+    for m in muls:
+        c, nc = m.args_cnc(cset=False)
+        if c:
+            c_mul = m.func(*c)
+            if nc:
+                if c_mul == 1:
+                    new_obj = m.func(*nc)
+                else:
+                    if isinstance(m, MatMul):
+                        new_obj = m.func(c_mul, *nc, evaluate=False)
+                    else:
+                        new_obj = m.func(c_mul, m.func(*nc), evaluate=False)
+                opt_subs[m] = new_obj
+            if len(c) > 1:
+                commutative_muls.add(c_mul)
+
+    match_common_args(Add, adds, opt_subs)
+    match_common_args(Mul, commutative_muls, opt_subs)
+
+    return opt_subs
+
+
+def tree_cse(exprs, symbols, opt_subs=None, order='canonical', ignore=()):
+    """Perform raw CSE on expression tree, taking opt_subs into account.
+
+    Parameters
+    ==========
+
+    exprs : list of SymPy expressions
+        The expressions to reduce.
+    symbols : infinite iterator yielding unique Symbols
+        The symbols used to label the common subexpressions which are pulled
+        out.
+    opt_subs : dictionary of expression substitutions
+        The expressions to be substituted before any CSE action is performed.
+    order : string, 'none' or 'canonical'
+        The order by which Mul and Add arguments are processed. For large
+        expressions where speed is a concern, use the setting order='none'.
+    ignore : iterable of Symbols
+        Substitutions containing any Symbol from ``ignore`` will be ignored.
+    """
+    if opt_subs is None:
+        opt_subs = {}
+
+    ## Find repeated sub-expressions
+
+    to_eliminate = set()
+
+    seen_subexp = set()
+    excluded_symbols = set()
+
+    def _find_repeated(expr):
+        if not isinstance(expr, (Basic, Unevaluated)):
+            return
+
+        if isinstance(expr, RootOf):
+            return
+
+        if isinstance(expr, Basic) and (
+                expr.is_Atom or
+                expr.is_Order or
+                isinstance(expr, (MatrixSymbol, MatrixElement))):
+            if expr.is_Symbol:
+                excluded_symbols.add(expr)
+            return
+
+        if iterable(expr):
+            args = expr
+
+        else:
+            if expr in seen_subexp:
+                for ign in ignore:
+                    if ign in expr.free_symbols:
+                        break
+                else:
+                    to_eliminate.add(expr)
+                    return
+
+            seen_subexp.add(expr)
+
+            if expr in opt_subs:
+                expr = opt_subs[expr]
+
+            args = expr.args
+
+        list(map(_find_repeated, args))
+
+    for e in exprs:
+        if isinstance(e, Basic):
+            _find_repeated(e)
+
+    ## Rebuild tree
+
+    # Remove symbols from the generator that conflict with names in the expressions.
+    symbols = (symbol for symbol in symbols if symbol not in excluded_symbols)
+
+    replacements = []
+
+    subs = {}
+
+    def _rebuild(expr):
+        if not isinstance(expr, (Basic, Unevaluated)):
+            return expr
+
+        if not expr.args:
+            return expr
+
+        if iterable(expr):
+            new_args = [_rebuild(arg) for arg in expr.args]
+            return expr.func(*new_args)
+
+        if expr in subs:
+            return subs[expr]
+
+        orig_expr = expr
+        if expr in opt_subs:
+            expr = opt_subs[expr]
+
+        # If enabled, parse Muls and Adds arguments by order to ensure
+        # replacement order independent from hashes
+        if order != 'none':
+            if isinstance(expr, (Mul, MatMul)):
+                c, nc = expr.args_cnc()
+                if c == [1]:
+                    args = nc
+                else:
+                    args = list(ordered(c)) + nc
+            elif isinstance(expr, (Add, MatAdd)):
+                args = list(ordered(expr.args))
+            else:
+                args = expr.args
+        else:
+            args = expr.args
+
+        new_args = list(map(_rebuild, args))
+        if isinstance(expr, Unevaluated) or new_args != args:
+            new_expr = expr.func(*new_args)
+        else:
+            new_expr = expr
+
+        if orig_expr in to_eliminate:
+            try:
+                sym = next(symbols)
+            except StopIteration:
+                raise ValueError("Symbols iterator ran out of symbols.")
+
+            if isinstance(orig_expr, MatrixExpr):
+                sym = MatrixSymbol(sym.name, orig_expr.rows,
+                    orig_expr.cols)
+
+            subs[orig_expr] = sym
+            replacements.append((sym, new_expr))
+            return sym
+
+        else:
+            return new_expr
+
+    reduced_exprs = []
+    for e in exprs:
+        if isinstance(e, Basic):
+            reduced_e = _rebuild(e)
+        else:
+            reduced_e = e
+        reduced_exprs.append(reduced_e)
+    return replacements, reduced_exprs
+
+
+def cse(exprs, symbols=None, optimizations=None, postprocess=None,
+        order='canonical', ignore=(), list=True):
+    """ Perform common subexpression elimination on an expression.
+
+    Parameters
+    ==========
+
+    exprs : list of SymPy expressions, or a single SymPy expression
+        The expressions to reduce.
+    symbols : infinite iterator yielding unique Symbols
+        The symbols used to label the common subexpressions which are pulled
+        out. The ``numbered_symbols`` generator is useful. The default is a
+        stream of symbols of the form "x0", "x1", etc. This must be an
+        infinite iterator.
+    optimizations : list of (callable, callable) pairs
+        The (preprocessor, postprocessor) pairs of external optimization
+        functions. Optionally 'basic' can be passed for a set of predefined
+        basic optimizations. Such 'basic' optimizations were used by default
+        in old implementation, however they can be really slow on larger
+        expressions. Now, no pre or post optimizations are made by default.
+    postprocess : a function which accepts the two return values of cse and
+        returns the desired form of output from cse, e.g. if you want the
+        replacements reversed the function might be the following lambda:
+        lambda r, e: return reversed(r), e
+    order : string, 'none' or 'canonical'
+        The order by which Mul and Add arguments are processed. If set to
+        'canonical', arguments will be canonically ordered. If set to 'none',
+        ordering will be faster but dependent on expressions hashes, thus
+        machine dependent and variable. For large expressions where speed is a
+        concern, use the setting order='none'.
+    ignore : iterable of Symbols
+        Substitutions containing any Symbol from ``ignore`` will be ignored.
+    list : bool, (default True)
+        Returns expression in list or else with same type as input (when False).
+
+    Returns
+    =======
+
+    replacements : list of (Symbol, expression) pairs
+        All of the common subexpressions that were replaced. Subexpressions
+        earlier in this list might show up in subexpressions later in this
+        list.
+    reduced_exprs : list of SymPy expressions
+        The reduced expressions with all of the replacements above.
+
+    Examples
+    ========
+
+    >>> from sympy import cse, SparseMatrix
+    >>> from sympy.abc import x, y, z, w
+    >>> cse(((w + x + y + z)*(w + y + z))/(w + x)**3)
+    ([(x0, y + z), (x1, w + x)], [(w + x0)*(x0 + x1)/x1**3])
+
+
+    List of expressions with recursive substitutions:
+
+    >>> m = SparseMatrix([x + y, x + y + z])
+    >>> cse([(x+y)**2, x + y + z, y + z, x + z + y, m])
+    ([(x0, x + y), (x1, x0 + z)], [x0**2, x1, y + z, x1, Matrix([
+    [x0],
+    [x1]])])
+
+    Note: the type and mutability of input matrices is retained.
+
+    >>> isinstance(_[1][-1], SparseMatrix)
+    True
+
+    The user may disallow substitutions containing certain symbols:
+
+    >>> cse([y**2*(x + 1), 3*y**2*(x + 1)], ignore=(y,))
+    ([(x0, x + 1)], [x0*y**2, 3*x0*y**2])
+
+    The default return value for the reduced expression(s) is a list, even if there is only
+    one expression. The `list` flag preserves the type of the input in the output:
+
+    >>> cse(x)
+    ([], [x])
+    >>> cse(x, list=False)
+    ([], x)
+    """
+    if not list:
+        return _cse_homogeneous(exprs,
+            symbols=symbols, optimizations=optimizations,
+            postprocess=postprocess, order=order, ignore=ignore)
+
+    if isinstance(exprs, (int, float)):
+        exprs = sympify(exprs)
+
+    # Handle the case if just one expression was passed.
+    if isinstance(exprs, (Basic, MatrixBase)):
+        exprs = [exprs]
+
+    copy = exprs
+    temp = []
+    for e in exprs:
+        if isinstance(e, (Matrix, ImmutableMatrix)):
+            temp.append(Tuple(*e.flat()))
+        elif isinstance(e, (SparseMatrix, ImmutableSparseMatrix)):
+            temp.append(Tuple(*e.todok().items()))
+        else:
+            temp.append(e)
+    exprs = temp
+    del temp
+
+    if optimizations is None:
+        optimizations = []
+    elif optimizations == 'basic':
+        optimizations = basic_optimizations
+
+    # Preprocess the expressions to give us better optimization opportunities.
+    reduced_exprs = [preprocess_for_cse(e, optimizations) for e in exprs]
+
+    if symbols is None:
+        symbols = numbered_symbols(cls=Symbol)
+    else:
+        # In case we get passed an iterable with an __iter__ method instead of
+        # an actual iterator.
+        symbols = iter(symbols)
+
+    # Find other optimization opportunities.
+    opt_subs = opt_cse(reduced_exprs, order)
+
+    # Main CSE algorithm.
+    replacements, reduced_exprs = tree_cse(reduced_exprs, symbols, opt_subs,
+                                           order, ignore)
+
+    # Postprocess the expressions to return the expressions to canonical form.
+    exprs = copy
+    for i, (sym, subtree) in enumerate(replacements):
+        subtree = postprocess_for_cse(subtree, optimizations)
+        replacements[i] = (sym, subtree)
+    reduced_exprs = [postprocess_for_cse(e, optimizations)
+                     for e in reduced_exprs]
+
+    # Get the matrices back
+    for i, e in enumerate(exprs):
+        if isinstance(e, (Matrix, ImmutableMatrix)):
+            reduced_exprs[i] = Matrix(e.rows, e.cols, reduced_exprs[i])
+            if isinstance(e, ImmutableMatrix):
+                reduced_exprs[i] = reduced_exprs[i].as_immutable()
+        elif isinstance(e, (SparseMatrix, ImmutableSparseMatrix)):
+            m = SparseMatrix(e.rows, e.cols, {})
+            for k, v in reduced_exprs[i]:
+                m[k] = v
+            if isinstance(e, ImmutableSparseMatrix):
+                m = m.as_immutable()
+            reduced_exprs[i] = m
+
+    if postprocess is None:
+        return replacements, reduced_exprs
+
+    return postprocess(replacements, reduced_exprs)
+
+
+def _cse_homogeneous(exprs, **kwargs):
+    """
+    Same as ``cse`` but the ``reduced_exprs`` are returned
+    with the same type as ``exprs`` or a sympified version of the same.
+
+    Parameters
+    ==========
+
+    exprs : an Expr, iterable of Expr or dictionary with Expr values
+        the expressions in which repeated subexpressions will be identified
+    kwargs : additional arguments for the ``cse`` function
+
+    Returns
+    =======
+
+    replacements : list of (Symbol, expression) pairs
+        All of the common subexpressions that were replaced. Subexpressions
+        earlier in this list might show up in subexpressions later in this
+        list.
+    reduced_exprs : list of SymPy expressions
+        The reduced expressions with all of the replacements above.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.cse_main import cse
+    >>> from sympy import cos, Tuple, Matrix
+    >>> from sympy.abc import x
+    >>> output = lambda x: type(cse(x, list=False)[1])
+    >>> output(1)
+    <class 'sympy.core.numbers.One'>
+    >>> output('cos(x)')
+    <class 'str'>
+    >>> output(cos(x))
+    cos
+    >>> output(Tuple(1, x))
+    <class 'sympy.core.containers.Tuple'>
+    >>> output(Matrix([[1,0], [0,1]]))
+    <class 'sympy.matrices.dense.MutableDenseMatrix'>
+    >>> output([1, x])
+    <class 'list'>
+    >>> output((1, x))
+    <class 'tuple'>
+    >>> output({1, x})
+    <class 'set'>
+    """
+    if isinstance(exprs, str):
+        replacements, reduced_exprs = _cse_homogeneous(
+            sympify(exprs), **kwargs)
+        return replacements, repr(reduced_exprs)
+    if isinstance(exprs, (list, tuple, set)):
+        replacements, reduced_exprs = cse(exprs, **kwargs)
+        return replacements, type(exprs)(reduced_exprs)
+    if isinstance(exprs, dict):
+        keys = list(exprs.keys()) # In order to guarantee the order of the elements.
+        replacements, values = cse([exprs[k] for k in keys], **kwargs)
+        reduced_exprs = dict(zip(keys, values))
+        return replacements, reduced_exprs
+
+    try:
+        replacements, (reduced_exprs,) = cse(exprs, **kwargs)
+    except TypeError: # For example 'mpf' objects
+        return [], exprs
+    else:
+        return replacements, reduced_exprs

venv/lib/python3.10/site-packages/sympy/simplify/cse_opts.py

@@ -0,0 +1,52 @@
+""" Optimizations of the expression tree representation for better CSE
+opportunities.
+"""
+from sympy.core import Add, Basic, Mul
+from sympy.core.singleton import S
+from sympy.core.sorting import default_sort_key
+from sympy.core.traversal import preorder_traversal
+
+
+def sub_pre(e):
+    """ Replace y - x with -(x - y) if -1 can be extracted from y - x.
+    """
+    # replacing Add, A, from which -1 can be extracted with -1*-A
+    adds = [a for a in e.atoms(Add) if a.could_extract_minus_sign()]
+    reps = {}
+    ignore = set()
+    for a in adds:
+        na = -a
+        if na.is_Mul:  # e.g. MatExpr
+            ignore.add(a)
+            continue
+        reps[a] = Mul._from_args([S.NegativeOne, na])
+
+    e = e.xreplace(reps)
+
+    # repeat again for persisting Adds but mark these with a leading 1, -1
+    # e.g. y - x -> 1*-1*(x - y)
+    if isinstance(e, Basic):
+        negs = {}
+        for a in sorted(e.atoms(Add), key=default_sort_key):
+            if a in ignore:
+                continue
+            if a in reps:
+                negs[a] = reps[a]
+            elif a.could_extract_minus_sign():
+                negs[a] = Mul._from_args([S.One, S.NegativeOne, -a])
+        e = e.xreplace(negs)
+    return e
+
+
+def sub_post(e):
+    """ Replace 1*-1*x with -x.
+    """
+    replacements = []
+    for node in preorder_traversal(e):
+        if isinstance(node, Mul) and \
+            node.args[0] is S.One and node.args[1] is S.NegativeOne:
+            replacements.append((node, -Mul._from_args(node.args[2:])))
+    for node, replacement in replacements:
+        e = e.xreplace({node: replacement})
+
+    return e

venv/lib/python3.10/site-packages/sympy/simplify/epathtools.py

@@ -0,0 +1,356 @@
+"""Tools for manipulation of expressions using paths. """
+
+from sympy.core import Basic
+
+
+class EPath:
+    r"""
+    Manipulate expressions using paths.
+
+    EPath grammar in EBNF notation::
+
+        literal   ::= /[A-Za-z_][A-Za-z_0-9]*/
+        number    ::= /-?\d+/
+        type      ::= literal
+        attribute ::= literal "?"
+        all       ::= "*"
+        slice     ::= "[" number? (":" number? (":" number?)?)? "]"
+        range     ::= all | slice
+        query     ::= (type | attribute) ("|" (type | attribute))*
+        selector  ::= range | query range?
+        path      ::= "/" selector ("/" selector)*
+
+    See the docstring of the epath() function.
+
+    """
+
+    __slots__ = ("_path", "_epath")
+
+    def __new__(cls, path):
+        """Construct new EPath. """
+        if isinstance(path, EPath):
+            return path
+
+        if not path:
+            raise ValueError("empty EPath")
+
+        _path = path
+
+        if path[0] == '/':
+            path = path[1:]
+        else:
+            raise NotImplementedError("non-root EPath")
+
+        epath = []
+
+        for selector in path.split('/'):
+            selector = selector.strip()
+
+            if not selector:
+                raise ValueError("empty selector")
+
+            index = 0
+
+            for c in selector:
+                if c.isalnum() or c in ('_', '|', '?'):
+                    index += 1
+                else:
+                    break
+
+            attrs = []
+            types = []
+
+            if index:
+                elements = selector[:index]
+                selector = selector[index:]
+
+                for element in elements.split('|'):
+                    element = element.strip()
+
+                    if not element:
+                        raise ValueError("empty element")
+
+                    if element.endswith('?'):
+                        attrs.append(element[:-1])
+                    else:
+                        types.append(element)
+
+            span = None
+
+            if selector == '*':
+                pass
+            else:
+                if selector.startswith('['):
+                    try:
+                        i = selector.index(']')
+                    except ValueError:
+                        raise ValueError("expected ']', got EOL")
+
+                    _span, span = selector[1:i], []
+
+                    if ':' not in _span:
+                        span = int(_span)
+                    else:
+                        for elt in _span.split(':', 3):
+                            if not elt:
+                                span.append(None)
+                            else:
+                                span.append(int(elt))
+
+                        span = slice(*span)
+
+                    selector = selector[i + 1:]
+
+                if selector:
+                    raise ValueError("trailing characters in selector")
+
+            epath.append((attrs, types, span))
+
+        obj = object.__new__(cls)
+
+        obj._path = _path
+        obj._epath = epath
+
+        return obj
+
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self._path)
+
+    def _get_ordered_args(self, expr):
+        """Sort ``expr.args`` using printing order. """
+        if expr.is_Add:
+            return expr.as_ordered_terms()
+        elif expr.is_Mul:
+            return expr.as_ordered_factors()
+        else:
+            return expr.args
+
+    def _hasattrs(self, expr, attrs):
+        """Check if ``expr`` has any of ``attrs``. """
+        for attr in attrs:
+            if not hasattr(expr, attr):
+                return False
+
+        return True
+
+    def _hastypes(self, expr, types):
+        """Check if ``expr`` is any of ``types``. """
+        _types = [ cls.__name__ for cls in expr.__class__.mro() ]
+        return bool(set(_types).intersection(types))
+
+    def _has(self, expr, attrs, types):
+        """Apply ``_hasattrs`` and ``_hastypes`` to ``expr``. """
+        if not (attrs or types):
+            return True
+
+        if attrs and self._hasattrs(expr, attrs):
+            return True
+
+        if types and self._hastypes(expr, types):
+            return True
+
+        return False
+
+    def apply(self, expr, func, args=None, kwargs=None):
+        """
+        Modify parts of an expression selected by a path.
+
+        Examples
+        ========
+
+        >>> from sympy.simplify.epathtools import EPath
+        >>> from sympy import sin, cos, E
+        >>> from sympy.abc import x, y, z, t
+
+        >>> path = EPath("/*/[0]/Symbol")
+        >>> expr = [((x, 1), 2), ((3, y), z)]
+
+        >>> path.apply(expr, lambda expr: expr**2)
+        [((x**2, 1), 2), ((3, y**2), z)]
+
+        >>> path = EPath("/*/*/Symbol")
+        >>> expr = t + sin(x + 1) + cos(x + y + E)
+
+        >>> path.apply(expr, lambda expr: 2*expr)
+        t + sin(2*x + 1) + cos(2*x + 2*y + E)
+
+        """
+        def _apply(path, expr, func):
+            if not path:
+                return func(expr)
+            else:
+                selector, path = path[0], path[1:]
+                attrs, types, span = selector
+
+                if isinstance(expr, Basic):
+                    if not expr.is_Atom:
+                        args, basic = self._get_ordered_args(expr), True
+                    else:
+                        return expr
+                elif hasattr(expr, '__iter__'):
+                    args, basic = expr, False
+                else:
+                    return expr
+
+                args = list(args)
+
+                if span is not None:
+                    if isinstance(span, slice):
+                        indices = range(*span.indices(len(args)))
+                    else:
+                        indices = [span]
+                else:
+                    indices = range(len(args))
+
+                for i in indices:
+                    try:
+                        arg = args[i]
+                    except IndexError:
+                        continue
+
+                    if self._has(arg, attrs, types):
+                        args[i] = _apply(path, arg, func)
+
+                if basic:
+                    return expr.func(*args)
+                else:
+                    return expr.__class__(args)
+
+        _args, _kwargs = args or (), kwargs or {}
+        _func = lambda expr: func(expr, *_args, **_kwargs)
+
+        return _apply(self._epath, expr, _func)
+
+    def select(self, expr):
+        """
+        Retrieve parts of an expression selected by a path.
+
+        Examples
+        ========
+
+        >>> from sympy.simplify.epathtools import EPath
+        >>> from sympy import sin, cos, E
+        >>> from sympy.abc import x, y, z, t
+
+        >>> path = EPath("/*/[0]/Symbol")
+        >>> expr = [((x, 1), 2), ((3, y), z)]
+
+        >>> path.select(expr)
+        [x, y]
+
+        >>> path = EPath("/*/*/Symbol")
+        >>> expr = t + sin(x + 1) + cos(x + y + E)
+
+        >>> path.select(expr)
+        [x, x, y]
+
+        """
+        result = []
+
+        def _select(path, expr):
+            if not path:
+                result.append(expr)
+            else:
+                selector, path = path[0], path[1:]
+                attrs, types, span = selector
+
+                if isinstance(expr, Basic):
+                    args = self._get_ordered_args(expr)
+                elif hasattr(expr, '__iter__'):
+                    args = expr
+                else:
+                    return
+
+                if span is not None:
+                    if isinstance(span, slice):
+                        args = args[span]
+                    else:
+                        try:
+                            args = [args[span]]
+                        except IndexError:
+                            return
+
+                for arg in args:
+                    if self._has(arg, attrs, types):
+                        _select(path, arg)
+
+        _select(self._epath, expr)
+        return result
+
+
+def epath(path, expr=None, func=None, args=None, kwargs=None):
+    r"""
+    Manipulate parts of an expression selected by a path.
+
+    Explanation
+    ===========
+
+    This function allows to manipulate large nested expressions in single
+    line of code, utilizing techniques to those applied in XML processing
+    standards (e.g. XPath).
+
+    If ``func`` is ``None``, :func:`epath` retrieves elements selected by
+    the ``path``. Otherwise it applies ``func`` to each matching element.
+
+    Note that it is more efficient to create an EPath object and use the select
+    and apply methods of that object, since this will compile the path string
+    only once.  This function should only be used as a convenient shortcut for
+    interactive use.
+
+    This is the supported syntax:
+
+    * select all: ``/*``
+          Equivalent of ``for arg in args:``.
+    * select slice: ``/[0]`` or ``/[1:5]`` or ``/[1:5:2]``
+          Supports standard Python's slice syntax.
+    * select by type: ``/list`` or ``/list|tuple``
+          Emulates ``isinstance()``.
+    * select by attribute: ``/__iter__?``
+          Emulates ``hasattr()``.
+
+    Parameters
+    ==========
+
+    path : str | EPath
+        A path as a string or a compiled EPath.
+    expr : Basic | iterable
+        An expression or a container of expressions.
+    func : callable (optional)
+        A callable that will be applied to matching parts.
+    args : tuple (optional)
+        Additional positional arguments to ``func``.
+    kwargs : dict (optional)
+        Additional keyword arguments to ``func``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.epathtools import epath
+    >>> from sympy import sin, cos, E
+    >>> from sympy.abc import x, y, z, t
+
+    >>> path = "/*/[0]/Symbol"
+    >>> expr = [((x, 1), 2), ((3, y), z)]
+
+    >>> epath(path, expr)
+    [x, y]
+    >>> epath(path, expr, lambda expr: expr**2)
+    [((x**2, 1), 2), ((3, y**2), z)]
+
+    >>> path = "/*/*/Symbol"
+    >>> expr = t + sin(x + 1) + cos(x + y + E)
+
+    >>> epath(path, expr)
+    [x, x, y]
+    >>> epath(path, expr, lambda expr: 2*expr)
+    t + sin(2*x + 1) + cos(2*x + 2*y + E)
+
+    """
+    _epath = EPath(path)
+
+    if expr is None:
+        return _epath
+    if func is None:
+        return _epath.select(expr)
+    else:
+        return _epath.apply(expr, func, args, kwargs)