Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/sympy/geometry/curve.py

@@ -0,0 +1,424 @@
+"""Curves in 2-dimensional Euclidean space.
+
+Contains
+========
+Curve
+
+"""
+
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core import diff
+from sympy.core.containers import Tuple
+from sympy.core.symbol import _symbol
+from sympy.geometry.entity import GeometryEntity, GeometrySet
+from sympy.geometry.point import Point
+from sympy.integrals import integrate
+from sympy.matrices import Matrix, rot_axis3
+from sympy.utilities.iterables import is_sequence
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+class Curve(GeometrySet):
+    """A curve in space.
+
+    A curve is defined by parametric functions for the coordinates, a
+    parameter and the lower and upper bounds for the parameter value.
+
+    Parameters
+    ==========
+
+    function : list of functions
+    limits : 3-tuple
+        Function parameter and lower and upper bounds.
+
+    Attributes
+    ==========
+
+    functions
+    parameter
+    limits
+
+    Raises
+    ======
+
+    ValueError
+        When `functions` are specified incorrectly.
+        When `limits` are specified incorrectly.
+
+    Examples
+    ========
+
+    >>> from sympy import Curve, sin, cos, interpolate
+    >>> from sympy.abc import t, a
+    >>> C = Curve((sin(t), cos(t)), (t, 0, 2))
+    >>> C.functions
+    (sin(t), cos(t))
+    >>> C.limits
+    (t, 0, 2)
+    >>> C.parameter
+    t
+    >>> C = Curve((t, interpolate([1, 4, 9, 16], t)), (t, 0, 1)); C
+    Curve((t, t**2), (t, 0, 1))
+    >>> C.subs(t, 4)
+    Point2D(4, 16)
+    >>> C.arbitrary_point(a)
+    Point2D(a, a**2)
+
+    See Also
+    ========
+
+    sympy.core.function.Function
+    sympy.polys.polyfuncs.interpolate
+
+    """
+
+    def __new__(cls, function, limits):
+        if not is_sequence(function) or len(function) != 2:
+            raise ValueError("Function argument should be (x(t), y(t)) "
+                "but got %s" % str(function))
+        if not is_sequence(limits) or len(limits) != 3:
+            raise ValueError("Limit argument should be (t, tmin, tmax) "
+                "but got %s" % str(limits))
+
+        return GeometryEntity.__new__(cls, Tuple(*function), Tuple(*limits))
+
+    def __call__(self, f):
+        return self.subs(self.parameter, f)
+
+    def _eval_subs(self, old, new):
+        if old == self.parameter:
+            return Point(*[f.subs(old, new) for f in self.functions])
+
+    def _eval_evalf(self, prec=15, **options):
+        f, (t, a, b) = self.args
+        dps = prec_to_dps(prec)
+        f = tuple([i.evalf(n=dps, **options) for i in f])
+        a, b = [i.evalf(n=dps, **options) for i in (a, b)]
+        return self.func(f, (t, a, b))
+
+    def arbitrary_point(self, parameter='t'):
+        """A parameterized point on the curve.
+
+        Parameters
+        ==========
+
+        parameter : str or Symbol, optional
+            Default value is 't'.
+            The Curve's parameter is selected with None or self.parameter
+            otherwise the provided symbol is used.
+
+        Returns
+        =======
+
+        Point :
+            Returns a point in parametric form.
+
+        Raises
+        ======
+
+        ValueError
+            When `parameter` already appears in the functions.
+
+        Examples
+        ========
+
+        >>> from sympy import Curve, Symbol
+        >>> from sympy.abc import s
+        >>> C = Curve([2*s, s**2], (s, 0, 2))
+        >>> C.arbitrary_point()
+        Point2D(2*t, t**2)
+        >>> C.arbitrary_point(C.parameter)
+        Point2D(2*s, s**2)
+        >>> C.arbitrary_point(None)
+        Point2D(2*s, s**2)
+        >>> C.arbitrary_point(Symbol('a'))
+        Point2D(2*a, a**2)
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        """
+        if parameter is None:
+            return Point(*self.functions)
+
+        tnew = _symbol(parameter, self.parameter, real=True)
+        t = self.parameter
+        if (tnew.name != t.name and
+                tnew.name in (f.name for f in self.free_symbols)):
+            raise ValueError('Symbol %s already appears in object '
+                'and cannot be used as a parameter.' % tnew.name)
+        return Point(*[w.subs(t, tnew) for w in self.functions])
+
+    @property
+    def free_symbols(self):
+        """Return a set of symbols other than the bound symbols used to
+        parametrically define the Curve.
+
+        Returns
+        =======
+
+        set :
+            Set of all non-parameterized symbols.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import t, a
+        >>> from sympy import Curve
+        >>> Curve((t, t**2), (t, 0, 2)).free_symbols
+        set()
+        >>> Curve((t, t**2), (t, a, 2)).free_symbols
+        {a}
+
+        """
+        free = set()
+        for a in self.functions + self.limits[1:]:
+            free |= a.free_symbols
+        free = free.difference({self.parameter})
+        return free
+
+    @property
+    def ambient_dimension(self):
+        """The dimension of the curve.
+
+        Returns
+        =======
+
+        int :
+            the dimension of curve.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import t
+        >>> from sympy import Curve
+        >>> C = Curve((t, t**2), (t, 0, 2))
+        >>> C.ambient_dimension
+        2
+
+        """
+
+        return len(self.args[0])
+
+    @property
+    def functions(self):
+        """The functions specifying the curve.
+
+        Returns
+        =======
+
+        functions :
+            list of parameterized coordinate functions.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import t
+        >>> from sympy import Curve
+        >>> C = Curve((t, t**2), (t, 0, 2))
+        >>> C.functions
+        (t, t**2)
+
+        See Also
+        ========
+
+        parameter
+
+        """
+        return self.args[0]
+
+    @property
+    def limits(self):
+        """The limits for the curve.
+
+        Returns
+        =======
+
+        limits : tuple
+            Contains parameter and lower and upper limits.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import t
+        >>> from sympy import Curve
+        >>> C = Curve([t, t**3], (t, -2, 2))
+        >>> C.limits
+        (t, -2, 2)
+
+        See Also
+        ========
+
+        plot_interval
+
+        """
+        return self.args[1]
+
+    @property
+    def parameter(self):
+        """The curve function variable.
+
+        Returns
+        =======
+
+        Symbol :
+            returns a bound symbol.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import t
+        >>> from sympy import Curve
+        >>> C = Curve([t, t**2], (t, 0, 2))
+        >>> C.parameter
+        t
+
+        See Also
+        ========
+
+        functions
+
+        """
+        return self.args[1][0]
+
+    @property
+    def length(self):
+        """The curve length.
+
+        Examples
+        ========
+
+        >>> from sympy import Curve
+        >>> from sympy.abc import t
+        >>> Curve((t, t), (t, 0, 1)).length
+        sqrt(2)
+
+        """
+        integrand = sqrt(sum(diff(func, self.limits[0])**2 for func in self.functions))
+        return integrate(integrand, self.limits)
+
+    def plot_interval(self, parameter='t'):
+        """The plot interval for the default geometric plot of the curve.
+
+        Parameters
+        ==========
+
+        parameter : str or Symbol, optional
+            Default value is 't';
+            otherwise the provided symbol is used.
+
+        Returns
+        =======
+
+        List :
+            the plot interval as below:
+                [parameter, lower_bound, upper_bound]
+
+        Examples
+        ========
+
+        >>> from sympy import Curve, sin
+        >>> from sympy.abc import x, s
+        >>> Curve((x, sin(x)), (x, 1, 2)).plot_interval()
+        [t, 1, 2]
+        >>> Curve((x, sin(x)), (x, 1, 2)).plot_interval(s)
+        [s, 1, 2]
+
+        See Also
+        ========
+
+        limits : Returns limits of the parameter interval
+
+        """
+        t = _symbol(parameter, self.parameter, real=True)
+        return [t] + list(self.limits[1:])
+
+    def rotate(self, angle=0, pt=None):
+        """This function is used to rotate a curve along given point ``pt`` at given angle(in radian).
+
+        Parameters
+        ==========
+
+        angle :
+            the angle at which the curve will be rotated(in radian) in counterclockwise direction.
+            default value of angle is 0.
+
+        pt : Point
+            the point along which the curve will be rotated.
+            If no point given, the curve will be rotated around origin.
+
+        Returns
+        =======
+
+        Curve :
+            returns a curve rotated at given angle along given point.
+
+        Examples
+        ========
+
+        >>> from sympy import Curve, pi
+        >>> from sympy.abc import x
+        >>> Curve((x, x), (x, 0, 1)).rotate(pi/2)
+        Curve((-x, x), (x, 0, 1))
+
+        """
+        if pt:
+            pt = -Point(pt, dim=2)
+        else:
+            pt = Point(0,0)
+        rv = self.translate(*pt.args)
+        f = list(rv.functions)
+        f.append(0)
+        f = Matrix(1, 3, f)
+        f *= rot_axis3(angle)
+        rv = self.func(f[0, :2].tolist()[0], self.limits)
+        pt = -pt
+        return rv.translate(*pt.args)
+
+    def scale(self, x=1, y=1, pt=None):
+        """Override GeometryEntity.scale since Curve is not made up of Points.
+
+        Returns
+        =======
+
+        Curve :
+            returns scaled curve.
+
+        Examples
+        ========
+
+        >>> from sympy import Curve
+        >>> from sympy.abc import x
+        >>> Curve((x, x), (x, 0, 1)).scale(2)
+        Curve((2*x, x), (x, 0, 1))
+
+        """
+        if pt:
+            pt = Point(pt, dim=2)
+            return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+        fx, fy = self.functions
+        return self.func((fx*x, fy*y), self.limits)
+
+    def translate(self, x=0, y=0):
+        """Translate the Curve by (x, y).
+
+        Returns
+        =======
+
+        Curve :
+            returns a translated curve.
+
+        Examples
+        ========
+
+        >>> from sympy import Curve
+        >>> from sympy.abc import x
+        >>> Curve((x, x), (x, 0, 1)).translate(1, 2)
+        Curve((x + 1, x + 2), (x, 0, 1))
+
+        """
+        fx, fy = self.functions
+        return self.func((fx + x, fy + y), self.limits)

env-llmeval/lib/python3.10/site-packages/sympy/geometry/line.py

@@ -0,0 +1,2803 @@
+"""Line-like geometrical entities.
+
+Contains
+========
+LinearEntity
+Line
+Ray
+Segment
+LinearEntity2D
+Line2D
+Ray2D
+Segment2D
+LinearEntity3D
+Line3D
+Ray3D
+Segment3D
+
+"""
+
+from sympy.core.containers import Tuple
+from sympy.core.evalf import N
+from sympy.core.expr import Expr
+from sympy.core.numbers import Rational, oo, Float
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import _symbol, Dummy, uniquely_named_symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (_pi_coeff, acos, tan, atan2)
+from .entity import GeometryEntity, GeometrySet
+from .exceptions import GeometryError
+from .point import Point, Point3D
+from .util import find, intersection
+from sympy.logic.boolalg import And
+from sympy.matrices import Matrix
+from sympy.sets.sets import Intersection
+from sympy.simplify.simplify import simplify
+from sympy.solvers.solvers import solve
+from sympy.solvers.solveset import linear_coeffs
+from sympy.utilities.misc import Undecidable, filldedent
+
+
+import random
+
+
+t, u = [Dummy('line_dummy') for i in range(2)]
+
+
+class LinearEntity(GeometrySet):
+    """A base class for all linear entities (Line, Ray and Segment)
+    in n-dimensional Euclidean space.
+
+    Attributes
+    ==========
+
+    ambient_dimension
+    direction
+    length
+    p1
+    p2
+    points
+
+    Notes
+    =====
+
+    This is an abstract class and is not meant to be instantiated.
+
+    See Also
+    ========
+
+    sympy.geometry.entity.GeometryEntity
+
+    """
+    def __new__(cls, p1, p2=None, **kwargs):
+        p1, p2 = Point._normalize_dimension(p1, p2)
+        if p1 == p2:
+            # sometimes we return a single point if we are not given two unique
+            # points. This is done in the specific subclass
+            raise ValueError(
+                "%s.__new__ requires two unique Points." % cls.__name__)
+        if len(p1) != len(p2):
+            raise ValueError(
+                "%s.__new__ requires two Points of equal dimension." % cls.__name__)
+
+        return GeometryEntity.__new__(cls, p1, p2, **kwargs)
+
+    def __contains__(self, other):
+        """Return a definitive answer or else raise an error if it cannot
+        be determined that other is on the boundaries of self."""
+        result = self.contains(other)
+
+        if result is not None:
+            return result
+        else:
+            raise Undecidable(
+                "Cannot decide whether '%s' contains '%s'" % (self, other))
+
+    def _span_test(self, other):
+        """Test whether the point `other` lies in the positive span of `self`.
+        A point x is 'in front' of a point y if x.dot(y) >= 0.  Return
+        -1 if `other` is behind `self.p1`, 0 if `other` is `self.p1` and
+        and 1 if `other` is in front of `self.p1`."""
+        if self.p1 == other:
+            return 0
+
+        rel_pos = other - self.p1
+        d = self.direction
+        if d.dot(rel_pos) > 0:
+            return 1
+        return -1
+
+    @property
+    def ambient_dimension(self):
+        """A property method that returns the dimension of LinearEntity
+        object.
+
+        Parameters
+        ==========
+
+        p1 : LinearEntity
+
+        Returns
+        =======
+
+        dimension : integer
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(1, 1)
+        >>> l1 = Line(p1, p2)
+        >>> l1.ambient_dimension
+        2
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0, 0), Point(1, 1, 1)
+        >>> l1 = Line(p1, p2)
+        >>> l1.ambient_dimension
+        3
+
+        """
+        return len(self.p1)
+
+    def angle_between(l1, l2):
+        """Return the non-reflex angle formed by rays emanating from
+        the origin with directions the same as the direction vectors
+        of the linear entities.
+
+        Parameters
+        ==========
+
+        l1 : LinearEntity
+        l2 : LinearEntity
+
+        Returns
+        =======
+
+        angle : angle in radians
+
+        Notes
+        =====
+
+        From the dot product of vectors v1 and v2 it is known that:
+
+            ``dot(v1, v2) = |v1|*|v2|*cos(A)``
+
+        where A is the angle formed between the two vectors. We can
+        get the directional vectors of the two lines and readily
+        find the angle between the two using the above formula.
+
+        See Also
+        ========
+
+        is_perpendicular, Ray2D.closing_angle
+
+        Examples
+        ========
+
+        >>> from sympy import Line
+        >>> e = Line((0, 0), (1, 0))
+        >>> ne = Line((0, 0), (1, 1))
+        >>> sw = Line((1, 1), (0, 0))
+        >>> ne.angle_between(e)
+        pi/4
+        >>> sw.angle_between(e)
+        3*pi/4
+
+        To obtain the non-obtuse angle at the intersection of lines, use
+        the ``smallest_angle_between`` method:
+
+        >>> sw.smallest_angle_between(e)
+        pi/4
+
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(-1, 2, 0)
+        >>> l1, l2 = Line3D(p1, p2), Line3D(p2, p3)
+        >>> l1.angle_between(l2)
+        acos(-sqrt(2)/3)
+        >>> l1.smallest_angle_between(l2)
+        acos(sqrt(2)/3)
+        """
+        if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+            raise TypeError('Must pass only LinearEntity objects')
+
+        v1, v2 = l1.direction, l2.direction
+        return acos(v1.dot(v2)/(abs(v1)*abs(v2)))
+
+    def smallest_angle_between(l1, l2):
+        """Return the smallest angle formed at the intersection of the
+        lines containing the linear entities.
+
+        Parameters
+        ==========
+
+        l1 : LinearEntity
+        l2 : LinearEntity
+
+        Returns
+        =======
+
+        angle : angle in radians
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2, p3 = Point(0, 0), Point(0, 4), Point(2, -2)
+        >>> l1, l2 = Line(p1, p2), Line(p1, p3)
+        >>> l1.smallest_angle_between(l2)
+        pi/4
+
+        See Also
+        ========
+
+        angle_between, is_perpendicular, Ray2D.closing_angle
+        """
+        if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+            raise TypeError('Must pass only LinearEntity objects')
+
+        v1, v2 = l1.direction, l2.direction
+        return acos(abs(v1.dot(v2))/(abs(v1)*abs(v2)))
+
+    def arbitrary_point(self, parameter='t'):
+        """A parameterized point on the Line.
+
+        Parameters
+        ==========
+
+        parameter : str, optional
+            The name of the parameter which will be used for the parametric
+            point. The default value is 't'. When this parameter is 0, the
+            first point used to define the line will be returned, and when
+            it is 1 the second point will be returned.
+
+        Returns
+        =======
+
+        point : Point
+
+        Raises
+        ======
+
+        ValueError
+            When ``parameter`` already appears in the Line's definition.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(1, 0), Point(5, 3)
+        >>> l1 = Line(p1, p2)
+        >>> l1.arbitrary_point()
+        Point2D(4*t + 1, 3*t)
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2 = Point3D(1, 0, 0), Point3D(5, 3, 1)
+        >>> l1 = Line3D(p1, p2)
+        >>> l1.arbitrary_point()
+        Point3D(4*t + 1, 3*t, t)
+
+        """
+        t = _symbol(parameter, real=True)
+        if t.name in (f.name for f in self.free_symbols):
+            raise ValueError(filldedent('''
+                Symbol %s already appears in object
+                and cannot be used as a parameter.
+                ''' % t.name))
+        # multiply on the right so the variable gets
+        # combined with the coordinates of the point
+        return self.p1 + (self.p2 - self.p1)*t
+
+    @staticmethod
+    def are_concurrent(*lines):
+        """Is a sequence of linear entities concurrent?
+
+        Two or more linear entities are concurrent if they all
+        intersect at a single point.
+
+        Parameters
+        ==========
+
+        lines
+            A sequence of linear entities.
+
+        Returns
+        =======
+
+        True : if the set of linear entities intersect in one point
+        False : otherwise.
+
+        See Also
+        ========
+
+        sympy.geometry.util.intersection
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(3, 5)
+        >>> p3, p4 = Point(-2, -2), Point(0, 2)
+        >>> l1, l2, l3 = Line(p1, p2), Line(p1, p3), Line(p1, p4)
+        >>> Line.are_concurrent(l1, l2, l3)
+        True
+        >>> l4 = Line(p2, p3)
+        >>> Line.are_concurrent(l2, l3, l4)
+        False
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(3, 5, 2)
+        >>> p3, p4 = Point3D(-2, -2, -2), Point3D(0, 2, 1)
+        >>> l1, l2, l3 = Line3D(p1, p2), Line3D(p1, p3), Line3D(p1, p4)
+        >>> Line3D.are_concurrent(l1, l2, l3)
+        True
+        >>> l4 = Line3D(p2, p3)
+        >>> Line3D.are_concurrent(l2, l3, l4)
+        False
+
+        """
+        common_points = Intersection(*lines)
+        if common_points.is_FiniteSet and len(common_points) == 1:
+            return True
+        return False
+
+    def contains(self, other):
+        """Subclasses should implement this method and should return
+            True if other is on the boundaries of self;
+            False if not on the boundaries of self;
+            None if a determination cannot be made."""
+        raise NotImplementedError()
+
+    @property
+    def direction(self):
+        """The direction vector of the LinearEntity.
+
+        Returns
+        =======
+
+        p : a Point; the ray from the origin to this point is the
+            direction of `self`
+
+        Examples
+        ========
+
+        >>> from sympy import Line
+        >>> a, b = (1, 1), (1, 3)
+        >>> Line(a, b).direction
+        Point2D(0, 2)
+        >>> Line(b, a).direction
+        Point2D(0, -2)
+
+        This can be reported so the distance from the origin is 1:
+
+        >>> Line(b, a).direction.unit
+        Point2D(0, -1)
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.unit
+
+        """
+        return self.p2 - self.p1
+
+    def intersection(self, other):
+        """The intersection with another geometrical entity.
+
+        Parameters
+        ==========
+
+        o : Point or LinearEntity
+
+        Returns
+        =======
+
+        intersection : list of geometrical entities
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line, Segment
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(7, 7)
+        >>> l1 = Line(p1, p2)
+        >>> l1.intersection(p3)
+        [Point2D(7, 7)]
+        >>> p4, p5 = Point(5, 0), Point(0, 3)
+        >>> l2 = Line(p4, p5)
+        >>> l1.intersection(l2)
+        [Point2D(15/8, 15/8)]
+        >>> p6, p7 = Point(0, 5), Point(2, 6)
+        >>> s1 = Segment(p6, p7)
+        >>> l1.intersection(s1)
+        []
+        >>> from sympy import Point3D, Line3D, Segment3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(7, 7, 7)
+        >>> l1 = Line3D(p1, p2)
+        >>> l1.intersection(p3)
+        [Point3D(7, 7, 7)]
+        >>> l1 = Line3D(Point3D(4,19,12), Point3D(5,25,17))
+        >>> l2 = Line3D(Point3D(-3, -15, -19), direction_ratio=[2,8,8])
+        >>> l1.intersection(l2)
+        [Point3D(1, 1, -3)]
+        >>> p6, p7 = Point3D(0, 5, 2), Point3D(2, 6, 3)
+        >>> s1 = Segment3D(p6, p7)
+        >>> l1.intersection(s1)
+        []
+
+        """
+        def intersect_parallel_rays(ray1, ray2):
+            if ray1.direction.dot(ray2.direction) > 0:
+                # rays point in the same direction
+                # so return the one that is "in front"
+                return [ray2] if ray1._span_test(ray2.p1) >= 0 else [ray1]
+            else:
+                # rays point in opposite directions
+                st = ray1._span_test(ray2.p1)
+                if st < 0:
+                    return []
+                elif st == 0:
+                    return [ray2.p1]
+                return [Segment(ray1.p1, ray2.p1)]
+
+        def intersect_parallel_ray_and_segment(ray, seg):
+            st1, st2 = ray._span_test(seg.p1), ray._span_test(seg.p2)
+            if st1 < 0 and st2 < 0:
+                return []
+            elif st1 >= 0 and st2 >= 0:
+                return [seg]
+            elif st1 >= 0:  # st2 < 0:
+                return [Segment(ray.p1, seg.p1)]
+            else:  # st1 < 0 and st2 >= 0:
+                return [Segment(ray.p1, seg.p2)]
+
+        def intersect_parallel_segments(seg1, seg2):
+            if seg1.contains(seg2):
+                return [seg2]
+            if seg2.contains(seg1):
+                return [seg1]
+
+            # direct the segments so they're oriented the same way
+            if seg1.direction.dot(seg2.direction) < 0:
+                seg2 = Segment(seg2.p2, seg2.p1)
+            # order the segments so seg1 is "behind" seg2
+            if seg1._span_test(seg2.p1) < 0:
+                seg1, seg2 = seg2, seg1
+            if seg2._span_test(seg1.p2) < 0:
+                return []
+            return [Segment(seg2.p1, seg1.p2)]
+
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if other.is_Point:
+            if self.contains(other):
+                return [other]
+            else:
+                return []
+        elif isinstance(other, LinearEntity):
+            # break into cases based on whether
+            # the lines are parallel, non-parallel intersecting, or skew
+            pts = Point._normalize_dimension(self.p1, self.p2, other.p1, other.p2)
+            rank = Point.affine_rank(*pts)
+
+            if rank == 1:
+                # we're collinear
+                if isinstance(self, Line):
+                    return [other]
+                if isinstance(other, Line):
+                    return [self]
+
+                if isinstance(self, Ray) and isinstance(other, Ray):
+                    return intersect_parallel_rays(self, other)
+                if isinstance(self, Ray) and isinstance(other, Segment):
+                    return intersect_parallel_ray_and_segment(self, other)
+                if isinstance(self, Segment) and isinstance(other, Ray):
+                    return intersect_parallel_ray_and_segment(other, self)
+                if isinstance(self, Segment) and isinstance(other, Segment):
+                    return intersect_parallel_segments(self, other)
+            elif rank == 2:
+                # we're in the same plane
+                l1 = Line(*pts[:2])
+                l2 = Line(*pts[2:])
+
+                # check to see if we're parallel.  If we are, we can't
+                # be intersecting, since the collinear case was already
+                # handled
+                if l1.direction.is_scalar_multiple(l2.direction):
+                    return []
+
+                # find the intersection as if everything were lines
+                # by solving the equation t*d + p1 == s*d' + p1'
+                m = Matrix([l1.direction, -l2.direction]).transpose()
+                v = Matrix([l2.p1 - l1.p1]).transpose()
+
+                # we cannot use m.solve(v) because that only works for square matrices
+                m_rref, pivots = m.col_insert(2, v).rref(simplify=True)
+                # rank == 2 ensures we have 2 pivots, but let's check anyway
+                if len(pivots) != 2:
+                    raise GeometryError("Failed when solving Mx=b when M={} and b={}".format(m, v))
+                coeff = m_rref[0, 2]
+                line_intersection = l1.direction*coeff + self.p1
+
+                # if both are lines, skip a containment check
+                if isinstance(self, Line) and isinstance(other, Line):
+                    return [line_intersection]
+
+                if ((isinstance(self, Line) or
+                     self.contains(line_intersection)) and
+                        other.contains(line_intersection)):
+                    return [line_intersection]
+                if not self.atoms(Float) and not other.atoms(Float):
+                    # if it can fail when there are no Floats then
+                    # maybe the following parametric check should be
+                    # done
+                    return []
+                # floats may fail exact containment so check that the
+                # arbitrary points, when  equal, both give a
+                # non-negative parameter when the arbitrary point
+                # coordinates are equated
+                tu = solve(self.arbitrary_point(t) - other.arbitrary_point(u),
+                    t, u, dict=True)[0]
+                def ok(p, l):
+                    if isinstance(l, Line):
+                        # p > -oo
+                        return True
+                    if isinstance(l, Ray):
+                        # p >= 0
+                        return p.is_nonnegative
+                    if isinstance(l, Segment):
+                        # 0 <= p <= 1
+                        return p.is_nonnegative and (1 - p).is_nonnegative
+                    raise ValueError("unexpected line type")
+                if ok(tu[t], self) and ok(tu[u], other):
+                    return [line_intersection]
+                return []
+            else:
+                # we're skew
+                return []
+
+        return other.intersection(self)
+
+    def is_parallel(l1, l2):
+        """Are two linear entities parallel?
+
+        Parameters
+        ==========
+
+        l1 : LinearEntity
+        l2 : LinearEntity
+
+        Returns
+        =======
+
+        True : if l1 and l2 are parallel,
+        False : otherwise.
+
+        See Also
+        ========
+
+        coefficients
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(1, 1)
+        >>> p3, p4 = Point(3, 4), Point(6, 7)
+        >>> l1, l2 = Line(p1, p2), Line(p3, p4)
+        >>> Line.is_parallel(l1, l2)
+        True
+        >>> p5 = Point(6, 6)
+        >>> l3 = Line(p3, p5)
+        >>> Line.is_parallel(l1, l3)
+        False
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(3, 4, 5)
+        >>> p3, p4 = Point3D(2, 1, 1), Point3D(8, 9, 11)
+        >>> l1, l2 = Line3D(p1, p2), Line3D(p3, p4)
+        >>> Line3D.is_parallel(l1, l2)
+        True
+        >>> p5 = Point3D(6, 6, 6)
+        >>> l3 = Line3D(p3, p5)
+        >>> Line3D.is_parallel(l1, l3)
+        False
+
+        """
+        if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+            raise TypeError('Must pass only LinearEntity objects')
+
+        return l1.direction.is_scalar_multiple(l2.direction)
+
+    def is_perpendicular(l1, l2):
+        """Are two linear entities perpendicular?
+
+        Parameters
+        ==========
+
+        l1 : LinearEntity
+        l2 : LinearEntity
+
+        Returns
+        =======
+
+        True : if l1 and l2 are perpendicular,
+        False : otherwise.
+
+        See Also
+        ========
+
+        coefficients
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(-1, 1)
+        >>> l1, l2 = Line(p1, p2), Line(p1, p3)
+        >>> l1.is_perpendicular(l2)
+        True
+        >>> p4 = Point(5, 3)
+        >>> l3 = Line(p1, p4)
+        >>> l1.is_perpendicular(l3)
+        False
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(-1, 2, 0)
+        >>> l1, l2 = Line3D(p1, p2), Line3D(p2, p3)
+        >>> l1.is_perpendicular(l2)
+        False
+        >>> p4 = Point3D(5, 3, 7)
+        >>> l3 = Line3D(p1, p4)
+        >>> l1.is_perpendicular(l3)
+        False
+
+        """
+        if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+            raise TypeError('Must pass only LinearEntity objects')
+
+        return S.Zero.equals(l1.direction.dot(l2.direction))
+
+    def is_similar(self, other):
+        """
+        Return True if self and other are contained in the same line.
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2, p3 = Point(0, 1), Point(3, 4), Point(2, 3)
+        >>> l1 = Line(p1, p2)
+        >>> l2 = Line(p1, p3)
+        >>> l1.is_similar(l2)
+        True
+        """
+        l = Line(self.p1, self.p2)
+        return l.contains(other)
+
+    @property
+    def length(self):
+        """
+        The length of the line.
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(3, 5)
+        >>> l1 = Line(p1, p2)
+        >>> l1.length
+        oo
+        """
+        return S.Infinity
+
+    @property
+    def p1(self):
+        """The first defining point of a linear entity.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(5, 3)
+        >>> l = Line(p1, p2)
+        >>> l.p1
+        Point2D(0, 0)
+
+        """
+        return self.args[0]
+
+    @property
+    def p2(self):
+        """The second defining point of a linear entity.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(5, 3)
+        >>> l = Line(p1, p2)
+        >>> l.p2
+        Point2D(5, 3)
+
+        """
+        return self.args[1]
+
+    def parallel_line(self, p):
+        """Create a new Line parallel to this linear entity which passes
+        through the point `p`.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        line : Line
+
+        See Also
+        ========
+
+        is_parallel
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2, p3 = Point(0, 0), Point(2, 3), Point(-2, 2)
+        >>> l1 = Line(p1, p2)
+        >>> l2 = l1.parallel_line(p3)
+        >>> p3 in l2
+        True
+        >>> l1.is_parallel(l2)
+        True
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(2, 3, 4), Point3D(-2, 2, 0)
+        >>> l1 = Line3D(p1, p2)
+        >>> l2 = l1.parallel_line(p3)
+        >>> p3 in l2
+        True
+        >>> l1.is_parallel(l2)
+        True
+
+        """
+        p = Point(p, dim=self.ambient_dimension)
+        return Line(p, p + self.direction)
+
+    def perpendicular_line(self, p):
+        """Create a new Line perpendicular to this linear entity which passes
+        through the point `p`.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        line : Line
+
+        See Also
+        ========
+
+        sympy.geometry.line.LinearEntity.is_perpendicular, perpendicular_segment
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(2, 3, 4), Point3D(-2, 2, 0)
+        >>> L = Line3D(p1, p2)
+        >>> P = L.perpendicular_line(p3); P
+        Line3D(Point3D(-2, 2, 0), Point3D(4/29, 6/29, 8/29))
+        >>> L.is_perpendicular(P)
+        True
+
+        In 3D the, the first point used to define the line is the point
+        through which the perpendicular was required to pass; the
+        second point is (arbitrarily) contained in the given line:
+
+        >>> P.p2 in L
+        True
+        """
+        p = Point(p, dim=self.ambient_dimension)
+        if p in self:
+            p = p + self.direction.orthogonal_direction
+        return Line(p, self.projection(p))
+
+    def perpendicular_segment(self, p):
+        """Create a perpendicular line segment from `p` to this line.
+
+        The endpoints of the segment are ``p`` and the closest point in
+        the line containing self. (If self is not a line, the point might
+        not be in self.)
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        segment : Segment
+
+        Notes
+        =====
+
+        Returns `p` itself if `p` is on this linear entity.
+
+        See Also
+        ========
+
+        perpendicular_line
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, 2)
+        >>> l1 = Line(p1, p2)
+        >>> s1 = l1.perpendicular_segment(p3)
+        >>> l1.is_perpendicular(s1)
+        True
+        >>> p3 in s1
+        True
+        >>> l1.perpendicular_segment(Point(4, 0))
+        Segment2D(Point2D(4, 0), Point2D(2, 2))
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, 2, 0)
+        >>> l1 = Line3D(p1, p2)
+        >>> s1 = l1.perpendicular_segment(p3)
+        >>> l1.is_perpendicular(s1)
+        True
+        >>> p3 in s1
+        True
+        >>> l1.perpendicular_segment(Point3D(4, 0, 0))
+        Segment3D(Point3D(4, 0, 0), Point3D(4/3, 4/3, 4/3))
+
+        """
+        p = Point(p, dim=self.ambient_dimension)
+        if p in self:
+            return p
+        l = self.perpendicular_line(p)
+        # The intersection should be unique, so unpack the singleton
+        p2, = Intersection(Line(self.p1, self.p2), l)
+
+        return Segment(p, p2)
+
+    @property
+    def points(self):
+        """The two points used to define this linear entity.
+
+        Returns
+        =======
+
+        points : tuple of Points
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(5, 11)
+        >>> l1 = Line(p1, p2)
+        >>> l1.points
+        (Point2D(0, 0), Point2D(5, 11))
+
+        """
+        return (self.p1, self.p2)
+
+    def projection(self, other):
+        """Project a point, line, ray, or segment onto this linear entity.
+
+        Parameters
+        ==========
+
+        other : Point or LinearEntity (Line, Ray, Segment)
+
+        Returns
+        =======
+
+        projection : Point or LinearEntity (Line, Ray, Segment)
+            The return type matches the type of the parameter ``other``.
+
+        Raises
+        ======
+
+        GeometryError
+            When method is unable to perform projection.
+
+        Notes
+        =====
+
+        A projection involves taking the two points that define
+        the linear entity and projecting those points onto a
+        Line and then reforming the linear entity using these
+        projections.
+        A point P is projected onto a line L by finding the point
+        on L that is closest to P. This point is the intersection
+        of L and the line perpendicular to L that passes through P.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point, perpendicular_line
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line, Segment, Rational
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(Rational(1, 2), 0)
+        >>> l1 = Line(p1, p2)
+        >>> l1.projection(p3)
+        Point2D(1/4, 1/4)
+        >>> p4, p5 = Point(10, 0), Point(12, 1)
+        >>> s1 = Segment(p4, p5)
+        >>> l1.projection(s1)
+        Segment2D(Point2D(5, 5), Point2D(13/2, 13/2))
+        >>> p1, p2, p3 = Point(0, 0, 1), Point(1, 1, 2), Point(2, 0, 1)
+        >>> l1 = Line(p1, p2)
+        >>> l1.projection(p3)
+        Point3D(2/3, 2/3, 5/3)
+        >>> p4, p5 = Point(10, 0, 1), Point(12, 1, 3)
+        >>> s1 = Segment(p4, p5)
+        >>> l1.projection(s1)
+        Segment3D(Point3D(10/3, 10/3, 13/3), Point3D(5, 5, 6))
+
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+
+        def proj_point(p):
+            return Point.project(p - self.p1, self.direction) + self.p1
+
+        if isinstance(other, Point):
+            return proj_point(other)
+        elif isinstance(other, LinearEntity):
+            p1, p2 = proj_point(other.p1), proj_point(other.p2)
+            # test to see if we're degenerate
+            if p1 == p2:
+                return p1
+            projected = other.__class__(p1, p2)
+            projected = Intersection(self, projected)
+            if projected.is_empty:
+                return projected
+            # if we happen to have intersected in only a point, return that
+            if projected.is_FiniteSet and len(projected) == 1:
+                # projected is a set of size 1, so unpack it in `a`
+                a, = projected
+                return a
+            # order args so projection is in the same direction as self
+            if self.direction.dot(projected.direction) < 0:
+                p1, p2 = projected.args
+                projected = projected.func(p2, p1)
+            return projected
+
+        raise GeometryError(
+            "Do not know how to project %s onto %s" % (other, self))
+
+    def random_point(self, seed=None):
+        """A random point on a LinearEntity.
+
+        Returns
+        =======
+
+        point : Point
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line, Ray, Segment
+        >>> p1, p2 = Point(0, 0), Point(5, 3)
+        >>> line = Line(p1, p2)
+        >>> r = line.random_point(seed=42)  # seed value is optional
+        >>> r.n(3)
+        Point2D(-0.72, -0.432)
+        >>> r in line
+        True
+        >>> Ray(p1, p2).random_point(seed=42).n(3)
+        Point2D(0.72, 0.432)
+        >>> Segment(p1, p2).random_point(seed=42).n(3)
+        Point2D(3.2, 1.92)
+
+        """
+        if seed is not None:
+            rng = random.Random(seed)
+        else:
+            rng = random
+        pt = self.arbitrary_point(t)
+        if isinstance(self, Ray):
+            v = abs(rng.gauss(0, 1))
+        elif isinstance(self, Segment):
+            v = rng.random()
+        elif isinstance(self, Line):
+            v = rng.gauss(0, 1)
+        else:
+            raise NotImplementedError('unhandled line type')
+        return pt.subs(t, Rational(v))
+
+    def bisectors(self, other):
+        """Returns the perpendicular lines which pass through the intersections
+        of self and other that are in the same plane.
+
+        Parameters
+        ==========
+
+        line : Line3D
+
+        Returns
+        =======
+
+        list: two Line instances
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D
+        >>> r1 = Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))
+        >>> r2 = Line3D(Point3D(0, 0, 0), Point3D(0, 1, 0))
+        >>> r1.bisectors(r2)
+        [Line3D(Point3D(0, 0, 0), Point3D(1, 1, 0)), Line3D(Point3D(0, 0, 0), Point3D(1, -1, 0))]
+
+        """
+        if not isinstance(other, LinearEntity):
+            raise GeometryError("Expecting LinearEntity, not %s" % other)
+
+        l1, l2 = self, other
+
+        # make sure dimensions match or else a warning will rise from
+        # intersection calculation
+        if l1.p1.ambient_dimension != l2.p1.ambient_dimension:
+            if isinstance(l1, Line2D):
+                l1, l2 = l2, l1
+            _, p1 = Point._normalize_dimension(l1.p1, l2.p1, on_morph='ignore')
+            _, p2 = Point._normalize_dimension(l1.p2, l2.p2, on_morph='ignore')
+            l2 = Line(p1, p2)
+
+        point = intersection(l1, l2)
+
+        # Three cases: Lines may intersect in a point, may be equal or may not intersect.
+        if not point:
+            raise GeometryError("The lines do not intersect")
+        else:
+            pt = point[0]
+            if isinstance(pt, Line):
+                # Intersection is a line because both lines are coincident
+                return [self]
+
+
+        d1 = l1.direction.unit
+        d2 = l2.direction.unit
+
+        bis1 = Line(pt, pt + d1 + d2)
+        bis2 = Line(pt, pt + d1 - d2)
+
+        return [bis1, bis2]
+
+
+class Line(LinearEntity):
+    """An infinite line in space.
+
+    A 2D line is declared with two distinct points, point and slope, or
+    an equation. A 3D line may be defined with a point and a direction ratio.
+
+    Parameters
+    ==========
+
+    p1 : Point
+    p2 : Point
+    slope : SymPy expression
+    direction_ratio : list
+    equation : equation of a line
+
+    Notes
+    =====
+
+    `Line` will automatically subclass to `Line2D` or `Line3D` based
+    on the dimension of `p1`.  The `slope` argument is only relevant
+    for `Line2D` and the `direction_ratio` argument is only relevant
+    for `Line3D`.
+
+    The order of the points will define the direction of the line
+    which is used when calculating the angle between lines.
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point
+    sympy.geometry.line.Line2D
+    sympy.geometry.line.Line3D
+
+    Examples
+    ========
+
+    >>> from sympy import Line, Segment, Point, Eq
+    >>> from sympy.abc import x, y, a, b
+
+    >>> L = Line(Point(2,3), Point(3,5))
+    >>> L
+    Line2D(Point2D(2, 3), Point2D(3, 5))
+    >>> L.points
+    (Point2D(2, 3), Point2D(3, 5))
+    >>> L.equation()
+    -2*x + y + 1
+    >>> L.coefficients
+    (-2, 1, 1)
+
+    Instantiate with keyword ``slope``:
+
+    >>> Line(Point(0, 0), slope=0)
+    Line2D(Point2D(0, 0), Point2D(1, 0))
+
+    Instantiate with another linear object
+
+    >>> s = Segment((0, 0), (0, 1))
+    >>> Line(s).equation()
+    x
+
+    The line corresponding to an equation in the for `ax + by + c = 0`,
+    can be entered:
+
+    >>> Line(3*x + y + 18)
+    Line2D(Point2D(0, -18), Point2D(1, -21))
+
+    If `x` or `y` has a different name, then they can be specified, too,
+    as a string (to match the name) or symbol:
+
+    >>> Line(Eq(3*a + b, -18), x='a', y=b)
+    Line2D(Point2D(0, -18), Point2D(1, -21))
+    """
+    def __new__(cls, *args, **kwargs):
+        if len(args) == 1 and isinstance(args[0], (Expr, Eq)):
+            missing = uniquely_named_symbol('?', args)
+            if not kwargs:
+                x = 'x'
+                y = 'y'
+            else:
+                x = kwargs.pop('x', missing)
+                y = kwargs.pop('y', missing)
+            if kwargs:
+                raise ValueError('expecting only x and y as keywords')
+
+            equation = args[0]
+            if isinstance(equation, Eq):
+                equation = equation.lhs - equation.rhs
+
+            def find_or_missing(x):
+                try:
+                    return find(x, equation)
+                except ValueError:
+                    return missing
+            x = find_or_missing(x)
+            y = find_or_missing(y)
+
+            a, b, c = linear_coeffs(equation, x, y)
+
+            if b:
+                return Line((0, -c/b), slope=-a/b)
+            if a:
+                return Line((-c/a, 0), slope=oo)
+
+            raise ValueError('not found in equation: %s' % (set('xy') - {x, y}))
+
+        else:
+            if len(args) > 0:
+                p1 = args[0]
+                if len(args) > 1:
+                    p2 = args[1]
+                else:
+                    p2 = None
+
+                if isinstance(p1, LinearEntity):
+                    if p2:
+                        raise ValueError('If p1 is a LinearEntity, p2 must be None.')
+                    dim = len(p1.p1)
+                else:
+                    p1 = Point(p1)
+                    dim = len(p1)
+                    if p2 is not None or isinstance(p2, Point) and p2.ambient_dimension != dim:
+                        p2 = Point(p2)
+
+                if dim == 2:
+                    return Line2D(p1, p2, **kwargs)
+                elif dim == 3:
+                    return Line3D(p1, p2, **kwargs)
+                return LinearEntity.__new__(cls, p1, p2, **kwargs)
+
+    def contains(self, other):
+        """
+        Return True if `other` is on this Line, or False otherwise.
+
+        Examples
+        ========
+
+        >>> from sympy import Line,Point
+        >>> p1, p2 = Point(0, 1), Point(3, 4)
+        >>> l = Line(p1, p2)
+        >>> l.contains(p1)
+        True
+        >>> l.contains((0, 1))
+        True
+        >>> l.contains((0, 0))
+        False
+        >>> a = (0, 0, 0)
+        >>> b = (1, 1, 1)
+        >>> c = (2, 2, 2)
+        >>> l1 = Line(a, b)
+        >>> l2 = Line(b, a)
+        >>> l1 == l2
+        False
+        >>> l1 in l2
+        True
+
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if isinstance(other, Point):
+            return Point.is_collinear(other, self.p1, self.p2)
+        if isinstance(other, LinearEntity):
+            return Point.is_collinear(self.p1, self.p2, other.p1, other.p2)
+        return False
+
+    def distance(self, other):
+        """
+        Finds the shortest distance between a line and a point.
+
+        Raises
+        ======
+
+        NotImplementedError is raised if `other` is not a Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(1, 1)
+        >>> s = Line(p1, p2)
+        >>> s.distance(Point(-1, 1))
+        sqrt(2)
+        >>> s.distance((-1, 2))
+        3*sqrt(2)/2
+        >>> p1, p2 = Point(0, 0, 0), Point(1, 1, 1)
+        >>> s = Line(p1, p2)
+        >>> s.distance(Point(-1, 1, 1))
+        2*sqrt(6)/3
+        >>> s.distance((-1, 1, 1))
+        2*sqrt(6)/3
+
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if self.contains(other):
+            return S.Zero
+        return self.perpendicular_segment(other).length
+
+    def equals(self, other):
+        """Returns True if self and other are the same mathematical entities"""
+        if not isinstance(other, Line):
+            return False
+        return Point.is_collinear(self.p1, other.p1, self.p2, other.p2)
+
+    def plot_interval(self, parameter='t'):
+        """The plot interval for the default geometric plot of line. Gives
+        values that will produce a line that is +/- 5 units long (where a
+        unit is the distance between the two points that define the line).
+
+        Parameters
+        ==========
+
+        parameter : str, optional
+            Default value is 't'.
+
+        Returns
+        =======
+
+        plot_interval : list (plot interval)
+            [parameter, lower_bound, upper_bound]
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(5, 3)
+        >>> l1 = Line(p1, p2)
+        >>> l1.plot_interval()
+        [t, -5, 5]
+
+        """
+        t = _symbol(parameter, real=True)
+        return [t, -5, 5]
+
+
+class Ray(LinearEntity):
+    """A Ray is a semi-line in the space with a source point and a direction.
+
+    Parameters
+    ==========
+
+    p1 : Point
+        The source of the Ray
+    p2 : Point or radian value
+        This point determines the direction in which the Ray propagates.
+        If given as an angle it is interpreted in radians with the positive
+        direction being ccw.
+
+    Attributes
+    ==========
+
+    source
+
+    See Also
+    ========
+
+    sympy.geometry.line.Ray2D
+    sympy.geometry.line.Ray3D
+    sympy.geometry.point.Point
+    sympy.geometry.line.Line
+
+    Notes
+    =====
+
+    `Ray` will automatically subclass to `Ray2D` or `Ray3D` based on the
+    dimension of `p1`.
+
+    Examples
+    ========
+
+    >>> from sympy import Ray, Point, pi
+    >>> r = Ray(Point(2, 3), Point(3, 5))
+    >>> r
+    Ray2D(Point2D(2, 3), Point2D(3, 5))
+    >>> r.points
+    (Point2D(2, 3), Point2D(3, 5))
+    >>> r.source
+    Point2D(2, 3)
+    >>> r.xdirection
+    oo
+    >>> r.ydirection
+    oo
+    >>> r.slope
+    2
+    >>> Ray(Point(0, 0), angle=pi/4).slope
+    1
+
+    """
+    def __new__(cls, p1, p2=None, **kwargs):
+        p1 = Point(p1)
+        if p2 is not None:
+            p1, p2 = Point._normalize_dimension(p1, Point(p2))
+        dim = len(p1)
+
+        if dim == 2:
+            return Ray2D(p1, p2, **kwargs)
+        elif dim == 3:
+            return Ray3D(p1, p2, **kwargs)
+        return LinearEntity.__new__(cls, p1, p2, **kwargs)
+
+    def _svg(self, scale_factor=1., fill_color="#66cc99"):
+        """Returns SVG path element for the LinearEntity.
+
+        Parameters
+        ==========
+
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        fill_color : str, optional
+            Hex string for fill color. Default is "#66cc99".
+        """
+        verts = (N(self.p1), N(self.p2))
+        coords = ["{},{}".format(p.x, p.y) for p in verts]
+        path = "M {} L {}".format(coords[0], " L ".join(coords[1:]))
+
+        return (
+            '<path fill-rule="evenodd" fill="{2}" stroke="#555555" '
+            'stroke-width="{0}" opacity="0.6" d="{1}" '
+            'marker-start="url(#markerCircle)" marker-end="url(#markerArrow)"/>'
+        ).format(2.*scale_factor, path, fill_color)
+
+    def contains(self, other):
+        """
+        Is other GeometryEntity contained in this Ray?
+
+        Examples
+        ========
+
+        >>> from sympy import Ray,Point,Segment
+        >>> p1, p2 = Point(0, 0), Point(4, 4)
+        >>> r = Ray(p1, p2)
+        >>> r.contains(p1)
+        True
+        >>> r.contains((1, 1))
+        True
+        >>> r.contains((1, 3))
+        False
+        >>> s = Segment((1, 1), (2, 2))
+        >>> r.contains(s)
+        True
+        >>> s = Segment((1, 2), (2, 5))
+        >>> r.contains(s)
+        False
+        >>> r1 = Ray((2, 2), (3, 3))
+        >>> r.contains(r1)
+        True
+        >>> r1 = Ray((2, 2), (3, 5))
+        >>> r.contains(r1)
+        False
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if isinstance(other, Point):
+            if Point.is_collinear(self.p1, self.p2, other):
+                # if we're in the direction of the ray, our
+                # direction vector dot the ray's direction vector
+                # should be non-negative
+                return bool((self.p2 - self.p1).dot(other - self.p1) >= S.Zero)
+            return False
+        elif isinstance(other, Ray):
+            if Point.is_collinear(self.p1, self.p2, other.p1, other.p2):
+                return bool((self.p2 - self.p1).dot(other.p2 - other.p1) > S.Zero)
+            return False
+        elif isinstance(other, Segment):
+            return other.p1 in self and other.p2 in self
+
+        # No other known entity can be contained in a Ray
+        return False
+
+    def distance(self, other):
+        """
+        Finds the shortest distance between the ray and a point.
+
+        Raises
+        ======
+
+        NotImplementedError is raised if `other` is not a Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ray
+        >>> p1, p2 = Point(0, 0), Point(1, 1)
+        >>> s = Ray(p1, p2)
+        >>> s.distance(Point(-1, -1))
+        sqrt(2)
+        >>> s.distance((-1, 2))
+        3*sqrt(2)/2
+        >>> p1, p2 = Point(0, 0, 0), Point(1, 1, 2)
+        >>> s = Ray(p1, p2)
+        >>> s
+        Ray3D(Point3D(0, 0, 0), Point3D(1, 1, 2))
+        >>> s.distance(Point(-1, -1, 2))
+        4*sqrt(3)/3
+        >>> s.distance((-1, -1, 2))
+        4*sqrt(3)/3
+
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if self.contains(other):
+            return S.Zero
+
+        proj = Line(self.p1, self.p2).projection(other)
+        if self.contains(proj):
+            return abs(other - proj)
+        else:
+            return abs(other - self.source)
+
+    def equals(self, other):
+        """Returns True if self and other are the same mathematical entities"""
+        if not isinstance(other, Ray):
+            return False
+        return self.source == other.source and other.p2 in self
+
+    def plot_interval(self, parameter='t'):
+        """The plot interval for the default geometric plot of the Ray. Gives
+        values that will produce a ray that is 10 units long (where a unit is
+        the distance between the two points that define the ray).
+
+        Parameters
+        ==========
+
+        parameter : str, optional
+            Default value is 't'.
+
+        Returns
+        =======
+
+        plot_interval : list
+            [parameter, lower_bound, upper_bound]
+
+        Examples
+        ========
+
+        >>> from sympy import Ray, pi
+        >>> r = Ray((0, 0), angle=pi/4)
+        >>> r.plot_interval()
+        [t, 0, 10]
+
+        """
+        t = _symbol(parameter, real=True)
+        return [t, 0, 10]
+
+    @property
+    def source(self):
+        """The point from which the ray emanates.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ray
+        >>> p1, p2 = Point(0, 0), Point(4, 1)
+        >>> r1 = Ray(p1, p2)
+        >>> r1.source
+        Point2D(0, 0)
+        >>> p1, p2 = Point(0, 0, 0), Point(4, 1, 5)
+        >>> r1 = Ray(p2, p1)
+        >>> r1.source
+        Point3D(4, 1, 5)
+
+        """
+        return self.p1
+
+
+class Segment(LinearEntity):
+    """A line segment in space.
+
+    Parameters
+    ==========
+
+    p1 : Point
+    p2 : Point
+
+    Attributes
+    ==========
+
+    length : number or SymPy expression
+    midpoint : Point
+
+    See Also
+    ========
+
+    sympy.geometry.line.Segment2D
+    sympy.geometry.line.Segment3D
+    sympy.geometry.point.Point
+    sympy.geometry.line.Line
+
+    Notes
+    =====
+
+    If 2D or 3D points are used to define `Segment`, it will
+    be automatically subclassed to `Segment2D` or `Segment3D`.
+
+    Examples
+    ========
+
+    >>> from sympy import Point, Segment
+    >>> Segment((1, 0), (1, 1)) # tuples are interpreted as pts
+    Segment2D(Point2D(1, 0), Point2D(1, 1))
+    >>> s = Segment(Point(4, 3), Point(1, 1))
+    >>> s.points
+    (Point2D(4, 3), Point2D(1, 1))
+    >>> s.slope
+    2/3
+    >>> s.length
+    sqrt(13)
+    >>> s.midpoint
+    Point2D(5/2, 2)
+    >>> Segment((1, 0, 0), (1, 1, 1)) # tuples are interpreted as pts
+    Segment3D(Point3D(1, 0, 0), Point3D(1, 1, 1))
+    >>> s = Segment(Point(4, 3, 9), Point(1, 1, 7)); s
+    Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7))
+    >>> s.points
+    (Point3D(4, 3, 9), Point3D(1, 1, 7))
+    >>> s.length
+    sqrt(17)
+    >>> s.midpoint
+    Point3D(5/2, 2, 8)
+
+    """
+    def __new__(cls, p1, p2, **kwargs):
+        p1, p2 = Point._normalize_dimension(Point(p1), Point(p2))
+        dim = len(p1)
+
+        if dim == 2:
+            return Segment2D(p1, p2, **kwargs)
+        elif dim == 3:
+            return Segment3D(p1, p2, **kwargs)
+        return LinearEntity.__new__(cls, p1, p2, **kwargs)
+
+    def contains(self, other):
+        """
+        Is the other GeometryEntity contained within this Segment?
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Segment
+        >>> p1, p2 = Point(0, 1), Point(3, 4)
+        >>> s = Segment(p1, p2)
+        >>> s2 = Segment(p2, p1)
+        >>> s.contains(s2)
+        True
+        >>> from sympy import Point3D, Segment3D
+        >>> p1, p2 = Point3D(0, 1, 1), Point3D(3, 4, 5)
+        >>> s = Segment3D(p1, p2)
+        >>> s2 = Segment3D(p2, p1)
+        >>> s.contains(s2)
+        True
+        >>> s.contains((p1 + p2)/2)
+        True
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if isinstance(other, Point):
+            if Point.is_collinear(other, self.p1, self.p2):
+                if isinstance(self, Segment2D):
+                    # if it is collinear and is in the bounding box of the
+                    # segment then it must be on the segment
+                    vert = (1/self.slope).equals(0)
+                    if vert is False:
+                        isin = (self.p1.x - other.x)*(self.p2.x - other.x) <= 0
+                        if isin in (True, False):
+                            return isin
+                    if vert is True:
+                        isin = (self.p1.y - other.y)*(self.p2.y - other.y) <= 0
+                        if isin in (True, False):
+                            return isin
+                # use the triangle inequality
+                d1, d2 = other - self.p1, other - self.p2
+                d = self.p2 - self.p1
+                # without the call to simplify, SymPy cannot tell that an expression
+                # like (a+b)*(a/2+b/2) is always non-negative.  If it cannot be
+                # determined, raise an Undecidable error
+                try:
+                    # the triangle inequality says that |d1|+|d2| >= |d| and is strict
+                    # only if other lies in the line segment
+                    return bool(simplify(Eq(abs(d1) + abs(d2) - abs(d), 0)))
+                except TypeError:
+                    raise Undecidable("Cannot determine if {} is in {}".format(other, self))
+        if isinstance(other, Segment):
+            return other.p1 in self and other.p2 in self
+
+        return False
+
+    def equals(self, other):
+        """Returns True if self and other are the same mathematical entities"""
+        return isinstance(other, self.func) and list(
+            ordered(self.args)) == list(ordered(other.args))
+
+    def distance(self, other):
+        """
+        Finds the shortest distance between a line segment and a point.
+
+        Raises
+        ======
+
+        NotImplementedError is raised if `other` is not a Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Segment
+        >>> p1, p2 = Point(0, 1), Point(3, 4)
+        >>> s = Segment(p1, p2)
+        >>> s.distance(Point(10, 15))
+        sqrt(170)
+        >>> s.distance((0, 12))
+        sqrt(73)
+        >>> from sympy import Point3D, Segment3D
+        >>> p1, p2 = Point3D(0, 0, 3), Point3D(1, 1, 4)
+        >>> s = Segment3D(p1, p2)
+        >>> s.distance(Point3D(10, 15, 12))
+        sqrt(341)
+        >>> s.distance((10, 15, 12))
+        sqrt(341)
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if isinstance(other, Point):
+            vp1 = other - self.p1
+            vp2 = other - self.p2
+
+            dot_prod_sign_1 = self.direction.dot(vp1) >= 0
+            dot_prod_sign_2 = self.direction.dot(vp2) <= 0
+            if dot_prod_sign_1 and dot_prod_sign_2:
+                return Line(self.p1, self.p2).distance(other)
+            if dot_prod_sign_1 and not dot_prod_sign_2:
+                return abs(vp2)
+            if not dot_prod_sign_1 and dot_prod_sign_2:
+                return abs(vp1)
+        raise NotImplementedError()
+
+    @property
+    def length(self):
+        """The length of the line segment.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.distance
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Segment
+        >>> p1, p2 = Point(0, 0), Point(4, 3)
+        >>> s1 = Segment(p1, p2)
+        >>> s1.length
+        5
+        >>> from sympy import Point3D, Segment3D
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(4, 3, 3)
+        >>> s1 = Segment3D(p1, p2)
+        >>> s1.length
+        sqrt(34)
+
+        """
+        return Point.distance(self.p1, self.p2)
+
+    @property
+    def midpoint(self):
+        """The midpoint of the line segment.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.midpoint
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Segment
+        >>> p1, p2 = Point(0, 0), Point(4, 3)
+        >>> s1 = Segment(p1, p2)
+        >>> s1.midpoint
+        Point2D(2, 3/2)
+        >>> from sympy import Point3D, Segment3D
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(4, 3, 3)
+        >>> s1 = Segment3D(p1, p2)
+        >>> s1.midpoint
+        Point3D(2, 3/2, 3/2)
+
+        """
+        return Point.midpoint(self.p1, self.p2)
+
+    def perpendicular_bisector(self, p=None):
+        """The perpendicular bisector of this segment.
+
+        If no point is specified or the point specified is not on the
+        bisector then the bisector is returned as a Line. Otherwise a
+        Segment is returned that joins the point specified and the
+        intersection of the bisector and the segment.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        bisector : Line or Segment
+
+        See Also
+        ========
+
+        LinearEntity.perpendicular_segment
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Segment
+        >>> p1, p2, p3 = Point(0, 0), Point(6, 6), Point(5, 1)
+        >>> s1 = Segment(p1, p2)
+        >>> s1.perpendicular_bisector()
+        Line2D(Point2D(3, 3), Point2D(-3, 9))
+
+        >>> s1.perpendicular_bisector(p3)
+        Segment2D(Point2D(5, 1), Point2D(3, 3))
+
+        """
+        l = self.perpendicular_line(self.midpoint)
+        if p is not None:
+            p2 = Point(p, dim=self.ambient_dimension)
+            if p2 in l:
+                return Segment(p2, self.midpoint)
+        return l
+
+    def plot_interval(self, parameter='t'):
+        """The plot interval for the default geometric plot of the Segment gives
+        values that will produce the full segment in a plot.
+
+        Parameters
+        ==========
+
+        parameter : str, optional
+            Default value is 't'.
+
+        Returns
+        =======
+
+        plot_interval : list
+            [parameter, lower_bound, upper_bound]
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Segment
+        >>> p1, p2 = Point(0, 0), Point(5, 3)
+        >>> s1 = Segment(p1, p2)
+        >>> s1.plot_interval()
+        [t, 0, 1]
+
+        """
+        t = _symbol(parameter, real=True)
+        return [t, 0, 1]
+
+
+class LinearEntity2D(LinearEntity):
+    """A base class for all linear entities (line, ray and segment)
+    in a 2-dimensional Euclidean space.
+
+    Attributes
+    ==========
+
+    p1
+    p2
+    coefficients
+    slope
+    points
+
+    Notes
+    =====
+
+    This is an abstract class and is not meant to be instantiated.
+
+    See Also
+    ========
+
+    sympy.geometry.entity.GeometryEntity
+
+    """
+    @property
+    def bounds(self):
+        """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+        rectangle for the geometric figure.
+
+        """
+        verts = self.points
+        xs = [p.x for p in verts]
+        ys = [p.y for p in verts]
+        return (min(xs), min(ys), max(xs), max(ys))
+
+    def perpendicular_line(self, p):
+        """Create a new Line perpendicular to this linear entity which passes
+        through the point `p`.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        line : Line
+
+        See Also
+        ========
+
+        sympy.geometry.line.LinearEntity.is_perpendicular, perpendicular_segment
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2, p3 = Point(0, 0), Point(2, 3), Point(-2, 2)
+        >>> L = Line(p1, p2)
+        >>> P = L.perpendicular_line(p3); P
+        Line2D(Point2D(-2, 2), Point2D(-5, 4))
+        >>> L.is_perpendicular(P)
+        True
+
+        In 2D, the first point of the perpendicular line is the
+        point through which was required to pass; the second
+        point is arbitrarily chosen. To get a line that explicitly
+        uses a point in the line, create a line from the perpendicular
+        segment from the line to the point:
+
+        >>> Line(L.perpendicular_segment(p3))
+        Line2D(Point2D(-2, 2), Point2D(4/13, 6/13))
+        """
+        p = Point(p, dim=self.ambient_dimension)
+        # any two lines in R^2 intersect, so blindly making
+        # a line through p in an orthogonal direction will work
+        # and is faster than finding the projection point as in 3D
+        return Line(p, p + self.direction.orthogonal_direction)
+
+    @property
+    def slope(self):
+        """The slope of this linear entity, or infinity if vertical.
+
+        Returns
+        =======
+
+        slope : number or SymPy expression
+
+        See Also
+        ========
+
+        coefficients
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(3, 5)
+        >>> l1 = Line(p1, p2)
+        >>> l1.slope
+        5/3
+
+        >>> p3 = Point(0, 4)
+        >>> l2 = Line(p1, p3)
+        >>> l2.slope
+        oo
+
+        """
+        d1, d2 = (self.p1 - self.p2).args
+        if d1 == 0:
+            return S.Infinity
+        return simplify(d2/d1)
+
+
+class Line2D(LinearEntity2D, Line):
+    """An infinite line in space 2D.
+
+    A line is declared with two distinct points or a point and slope
+    as defined using keyword `slope`.
+
+    Parameters
+    ==========
+
+    p1 : Point
+    pt : Point
+    slope : SymPy expression
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point
+
+    Examples
+    ========
+
+    >>> from sympy import Line, Segment, Point
+    >>> L = Line(Point(2,3), Point(3,5))
+    >>> L
+    Line2D(Point2D(2, 3), Point2D(3, 5))
+    >>> L.points
+    (Point2D(2, 3), Point2D(3, 5))
+    >>> L.equation()
+    -2*x + y + 1
+    >>> L.coefficients
+    (-2, 1, 1)
+
+    Instantiate with keyword ``slope``:
+
+    >>> Line(Point(0, 0), slope=0)
+    Line2D(Point2D(0, 0), Point2D(1, 0))
+
+    Instantiate with another linear object
+
+    >>> s = Segment((0, 0), (0, 1))
+    >>> Line(s).equation()
+    x
+    """
+    def __new__(cls, p1, pt=None, slope=None, **kwargs):
+        if isinstance(p1, LinearEntity):
+            if pt is not None:
+                raise ValueError('When p1 is a LinearEntity, pt should be None')
+            p1, pt = Point._normalize_dimension(*p1.args, dim=2)
+        else:
+            p1 = Point(p1, dim=2)
+        if pt is not None and slope is None:
+            try:
+                p2 = Point(pt, dim=2)
+            except (NotImplementedError, TypeError, ValueError):
+                raise ValueError(filldedent('''
+                    The 2nd argument was not a valid Point.
+                    If it was a slope, enter it with keyword "slope".
+                    '''))
+        elif slope is not None and pt is None:
+            slope = sympify(slope)
+            if slope.is_finite is False:
+                # when infinite slope, don't change x
+                dx = 0
+                dy = 1
+            else:
+                # go over 1 up slope
+                dx = 1
+                dy = slope
+            # XXX avoiding simplification by adding to coords directly
+            p2 = Point(p1.x + dx, p1.y + dy, evaluate=False)
+        else:
+            raise ValueError('A 2nd Point or keyword "slope" must be used.')
+        return LinearEntity2D.__new__(cls, p1, p2, **kwargs)
+
+    def _svg(self, scale_factor=1., fill_color="#66cc99"):
+        """Returns SVG path element for the LinearEntity.
+
+        Parameters
+        ==========
+
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        fill_color : str, optional
+            Hex string for fill color. Default is "#66cc99".
+        """
+        verts = (N(self.p1), N(self.p2))
+        coords = ["{},{}".format(p.x, p.y) for p in verts]
+        path = "M {} L {}".format(coords[0], " L ".join(coords[1:]))
+
+        return (
+            '<path fill-rule="evenodd" fill="{2}" stroke="#555555" '
+            'stroke-width="{0}" opacity="0.6" d="{1}" '
+            'marker-start="url(#markerReverseArrow)" marker-end="url(#markerArrow)"/>'
+        ).format(2.*scale_factor, path, fill_color)
+
+    @property
+    def coefficients(self):
+        """The coefficients (`a`, `b`, `c`) for `ax + by + c = 0`.
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line2D.equation
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> from sympy.abc import x, y
+        >>> p1, p2 = Point(0, 0), Point(5, 3)
+        >>> l = Line(p1, p2)
+        >>> l.coefficients
+        (-3, 5, 0)
+
+        >>> p3 = Point(x, y)
+        >>> l2 = Line(p1, p3)
+        >>> l2.coefficients
+        (-y, x, 0)
+
+        """
+        p1, p2 = self.points
+        if p1.x == p2.x:
+            return (S.One, S.Zero, -p1.x)
+        elif p1.y == p2.y:
+            return (S.Zero, S.One, -p1.y)
+        return tuple([simplify(i) for i in
+                      (self.p1.y - self.p2.y,
+                       self.p2.x - self.p1.x,
+                       self.p1.x*self.p2.y - self.p1.y*self.p2.x)])
+
+    def equation(self, x='x', y='y'):
+        """The equation of the line: ax + by + c.
+
+        Parameters
+        ==========
+
+        x : str, optional
+            The name to use for the x-axis, default value is 'x'.
+        y : str, optional
+            The name to use for the y-axis, default value is 'y'.
+
+        Returns
+        =======
+
+        equation : SymPy expression
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line2D.coefficients
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(1, 0), Point(5, 3)
+        >>> l1 = Line(p1, p2)
+        >>> l1.equation()
+        -3*x + 4*y + 3
+
+        """
+        x = _symbol(x, real=True)
+        y = _symbol(y, real=True)
+        p1, p2 = self.points
+        if p1.x == p2.x:
+            return x - p1.x
+        elif p1.y == p2.y:
+            return y - p1.y
+
+        a, b, c = self.coefficients
+        return a*x + b*y + c
+
+
+class Ray2D(LinearEntity2D, Ray):
+    """
+    A Ray is a semi-line in the space with a source point and a direction.
+
+    Parameters
+    ==========
+
+    p1 : Point
+        The source of the Ray
+    p2 : Point or radian value
+        This point determines the direction in which the Ray propagates.
+        If given as an angle it is interpreted in radians with the positive
+        direction being ccw.
+
+    Attributes
+    ==========
+
+    source
+    xdirection
+    ydirection
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point, Line
+
+    Examples
+    ========
+
+    >>> from sympy import Point, pi, Ray
+    >>> r = Ray(Point(2, 3), Point(3, 5))
+    >>> r
+    Ray2D(Point2D(2, 3), Point2D(3, 5))
+    >>> r.points
+    (Point2D(2, 3), Point2D(3, 5))
+    >>> r.source
+    Point2D(2, 3)
+    >>> r.xdirection
+    oo
+    >>> r.ydirection
+    oo
+    >>> r.slope
+    2
+    >>> Ray(Point(0, 0), angle=pi/4).slope
+    1
+
+    """
+    def __new__(cls, p1, pt=None, angle=None, **kwargs):
+        p1 = Point(p1, dim=2)
+        if pt is not None and angle is None:
+            try:
+                p2 = Point(pt, dim=2)
+            except (NotImplementedError, TypeError, ValueError):
+                raise ValueError(filldedent('''
+                    The 2nd argument was not a valid Point; if
+                    it was meant to be an angle it should be
+                    given with keyword "angle".'''))
+            if p1 == p2:
+                raise ValueError('A Ray requires two distinct points.')
+        elif angle is not None and pt is None:
+            # we need to know if the angle is an odd multiple of pi/2
+            angle = sympify(angle)
+            c = _pi_coeff(angle)
+            p2 = None
+            if c is not None:
+                if c.is_Rational:
+                    if c.q == 2:
+                        if c.p == 1:
+                            p2 = p1 + Point(0, 1)
+                        elif c.p == 3:
+                            p2 = p1 + Point(0, -1)
+                    elif c.q == 1:
+                        if c.p == 0:
+                            p2 = p1 + Point(1, 0)
+                        elif c.p == 1:
+                            p2 = p1 + Point(-1, 0)
+                if p2 is None:
+                    c *= S.Pi
+            else:
+                c = angle % (2*S.Pi)
+            if not p2:
+                m = 2*c/S.Pi
+                left = And(1 < m, m < 3)  # is it in quadrant 2 or 3?
+                x = Piecewise((-1, left), (Piecewise((0, Eq(m % 1, 0)), (1, True)), True))
+                y = Piecewise((-tan(c), left), (Piecewise((1, Eq(m, 1)), (-1, Eq(m, 3)), (tan(c), True)), True))
+                p2 = p1 + Point(x, y)
+        else:
+            raise ValueError('A 2nd point or keyword "angle" must be used.')
+
+        return LinearEntity2D.__new__(cls, p1, p2, **kwargs)
+
+    @property
+    def xdirection(self):
+        """The x direction of the ray.
+
+        Positive infinity if the ray points in the positive x direction,
+        negative infinity if the ray points in the negative x direction,
+        or 0 if the ray is vertical.
+
+        See Also
+        ========
+
+        ydirection
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ray
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, -1)
+        >>> r1, r2 = Ray(p1, p2), Ray(p1, p3)
+        >>> r1.xdirection
+        oo
+        >>> r2.xdirection
+        0
+
+        """
+        if self.p1.x < self.p2.x:
+            return S.Infinity
+        elif self.p1.x == self.p2.x:
+            return S.Zero
+        else:
+            return S.NegativeInfinity
+
+    @property
+    def ydirection(self):
+        """The y direction of the ray.
+
+        Positive infinity if the ray points in the positive y direction,
+        negative infinity if the ray points in the negative y direction,
+        or 0 if the ray is horizontal.
+
+        See Also
+        ========
+
+        xdirection
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ray
+        >>> p1, p2, p3 = Point(0, 0), Point(-1, -1), Point(-1, 0)
+        >>> r1, r2 = Ray(p1, p2), Ray(p1, p3)
+        >>> r1.ydirection
+        -oo
+        >>> r2.ydirection
+        0
+
+        """
+        if self.p1.y < self.p2.y:
+            return S.Infinity
+        elif self.p1.y == self.p2.y:
+            return S.Zero
+        else:
+            return S.NegativeInfinity
+
+    def closing_angle(r1, r2):
+        """Return the angle by which r2 must be rotated so it faces the same
+        direction as r1.
+
+        Parameters
+        ==========
+
+        r1 : Ray2D
+        r2 : Ray2D
+
+        Returns
+        =======
+
+        angle : angle in radians (ccw angle is positive)
+
+        See Also
+        ========
+
+        LinearEntity.angle_between
+
+        Examples
+        ========
+
+        >>> from sympy import Ray, pi
+        >>> r1 = Ray((0, 0), (1, 0))
+        >>> r2 = r1.rotate(-pi/2)
+        >>> angle = r1.closing_angle(r2); angle
+        pi/2
+        >>> r2.rotate(angle).direction.unit == r1.direction.unit
+        True
+        >>> r2.closing_angle(r1)
+        -pi/2
+        """
+        if not all(isinstance(r, Ray2D) for r in (r1, r2)):
+            # although the direction property is defined for
+            # all linear entities, only the Ray is truly a
+            # directed object
+            raise TypeError('Both arguments must be Ray2D objects.')
+
+        a1 = atan2(*list(reversed(r1.direction.args)))
+        a2 = atan2(*list(reversed(r2.direction.args)))
+        if a1*a2 < 0:
+            a1 = 2*S.Pi + a1 if a1 < 0 else a1
+            a2 = 2*S.Pi + a2 if a2 < 0 else a2
+        return a1 - a2
+
+
+class Segment2D(LinearEntity2D, Segment):
+    """A line segment in 2D space.
+
+    Parameters
+    ==========
+
+    p1 : Point
+    p2 : Point
+
+    Attributes
+    ==========
+
+    length : number or SymPy expression
+    midpoint : Point
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point, Line
+
+    Examples
+    ========
+
+    >>> from sympy import Point, Segment
+    >>> Segment((1, 0), (1, 1)) # tuples are interpreted as pts
+    Segment2D(Point2D(1, 0), Point2D(1, 1))
+    >>> s = Segment(Point(4, 3), Point(1, 1)); s
+    Segment2D(Point2D(4, 3), Point2D(1, 1))
+    >>> s.points
+    (Point2D(4, 3), Point2D(1, 1))
+    >>> s.slope
+    2/3
+    >>> s.length
+    sqrt(13)
+    >>> s.midpoint
+    Point2D(5/2, 2)
+
+    """
+    def __new__(cls, p1, p2, **kwargs):
+        p1 = Point(p1, dim=2)
+        p2 = Point(p2, dim=2)
+
+        if p1 == p2:
+            return p1
+
+        return LinearEntity2D.__new__(cls, p1, p2, **kwargs)
+
+    def _svg(self, scale_factor=1., fill_color="#66cc99"):
+        """Returns SVG path element for the LinearEntity.
+
+        Parameters
+        ==========
+
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        fill_color : str, optional
+            Hex string for fill color. Default is "#66cc99".
+        """
+        verts = (N(self.p1), N(self.p2))
+        coords = ["{},{}".format(p.x, p.y) for p in verts]
+        path = "M {} L {}".format(coords[0], " L ".join(coords[1:]))
+        return (
+            '<path fill-rule="evenodd" fill="{2}" stroke="#555555" '
+            'stroke-width="{0}" opacity="0.6" d="{1}" />'
+        ).format(2.*scale_factor, path, fill_color)
+
+
+class LinearEntity3D(LinearEntity):
+    """An base class for all linear entities (line, ray and segment)
+    in a 3-dimensional Euclidean space.
+
+    Attributes
+    ==========
+
+    p1
+    p2
+    direction_ratio
+    direction_cosine
+    points
+
+    Notes
+    =====
+
+    This is a base class and is not meant to be instantiated.
+    """
+    def __new__(cls, p1, p2, **kwargs):
+        p1 = Point3D(p1, dim=3)
+        p2 = Point3D(p2, dim=3)
+        if p1 == p2:
+            # if it makes sense to return a Point, handle in subclass
+            raise ValueError(
+                "%s.__new__ requires two unique Points." % cls.__name__)
+
+        return GeometryEntity.__new__(cls, p1, p2, **kwargs)
+
+    ambient_dimension = 3
+
+    @property
+    def direction_ratio(self):
+        """The direction ratio of a given line in 3D.
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line3D.equation
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(5, 3, 1)
+        >>> l = Line3D(p1, p2)
+        >>> l.direction_ratio
+        [5, 3, 1]
+        """
+        p1, p2 = self.points
+        return p1.direction_ratio(p2)
+
+    @property
+    def direction_cosine(self):
+        """The normalized direction ratio of a given line in 3D.
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line3D.equation
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(5, 3, 1)
+        >>> l = Line3D(p1, p2)
+        >>> l.direction_cosine
+        [sqrt(35)/7, 3*sqrt(35)/35, sqrt(35)/35]
+        >>> sum(i**2 for i in _)
+        1
+        """
+        p1, p2 = self.points
+        return p1.direction_cosine(p2)
+
+
+class Line3D(LinearEntity3D, Line):
+    """An infinite 3D line in space.
+
+    A line is declared with two distinct points or a point and direction_ratio
+    as defined using keyword `direction_ratio`.
+
+    Parameters
+    ==========
+
+    p1 : Point3D
+    pt : Point3D
+    direction_ratio : list
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point3D
+    sympy.geometry.line.Line
+    sympy.geometry.line.Line2D
+
+    Examples
+    ========
+
+    >>> from sympy import Line3D, Point3D
+    >>> L = Line3D(Point3D(2, 3, 4), Point3D(3, 5, 1))
+    >>> L
+    Line3D(Point3D(2, 3, 4), Point3D(3, 5, 1))
+    >>> L.points
+    (Point3D(2, 3, 4), Point3D(3, 5, 1))
+    """
+    def __new__(cls, p1, pt=None, direction_ratio=(), **kwargs):
+        if isinstance(p1, LinearEntity3D):
+            if pt is not None:
+                raise ValueError('if p1 is a LinearEntity, pt must be None.')
+            p1, pt = p1.args
+        else:
+            p1 = Point(p1, dim=3)
+        if pt is not None and len(direction_ratio) == 0:
+            pt = Point(pt, dim=3)
+        elif len(direction_ratio) == 3 and pt is None:
+            pt = Point3D(p1.x + direction_ratio[0], p1.y + direction_ratio[1],
+                         p1.z + direction_ratio[2])
+        else:
+            raise ValueError('A 2nd Point or keyword "direction_ratio" must '
+                             'be used.')
+
+        return LinearEntity3D.__new__(cls, p1, pt, **kwargs)
+
+    def equation(self, x='x', y='y', z='z'):
+        """Return the equations that define the line in 3D.
+
+        Parameters
+        ==========
+
+        x : str, optional
+            The name to use for the x-axis, default value is 'x'.
+        y : str, optional
+            The name to use for the y-axis, default value is 'y'.
+        z : str, optional
+            The name to use for the z-axis, default value is 'z'.
+
+        Returns
+        =======
+
+        equation : Tuple of simultaneous equations
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D, solve
+        >>> from sympy.abc import x, y, z
+        >>> p1, p2 = Point3D(1, 0, 0), Point3D(5, 3, 0)
+        >>> l1 = Line3D(p1, p2)
+        >>> eq = l1.equation(x, y, z); eq
+        (-3*x + 4*y + 3, z)
+        >>> solve(eq.subs(z, 0), (x, y, z))
+        {x: 4*y/3 + 1}
+        """
+        x, y, z, k = [_symbol(i, real=True) for i in (x, y, z, 'k')]
+        p1, p2 = self.points
+        d1, d2, d3 = p1.direction_ratio(p2)
+        x1, y1, z1 = p1
+        eqs = [-d1*k + x - x1, -d2*k + y - y1, -d3*k + z - z1]
+        # eliminate k from equations by solving first eq with k for k
+        for i, e in enumerate(eqs):
+            if e.has(k):
+                kk = solve(eqs[i], k)[0]
+                eqs.pop(i)
+                break
+        return Tuple(*[i.subs(k, kk).as_numer_denom()[0] for i in eqs])
+
+
+class Ray3D(LinearEntity3D, Ray):
+    """
+    A Ray is a semi-line in the space with a source point and a direction.
+
+    Parameters
+    ==========
+
+    p1 : Point3D
+        The source of the Ray
+    p2 : Point or a direction vector
+    direction_ratio: Determines the direction in which the Ray propagates.
+
+
+    Attributes
+    ==========
+
+    source
+    xdirection
+    ydirection
+    zdirection
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point3D, Line3D
+
+
+    Examples
+    ========
+
+    >>> from sympy import Point3D, Ray3D
+    >>> r = Ray3D(Point3D(2, 3, 4), Point3D(3, 5, 0))
+    >>> r
+    Ray3D(Point3D(2, 3, 4), Point3D(3, 5, 0))
+    >>> r.points
+    (Point3D(2, 3, 4), Point3D(3, 5, 0))
+    >>> r.source
+    Point3D(2, 3, 4)
+    >>> r.xdirection
+    oo
+    >>> r.ydirection
+    oo
+    >>> r.direction_ratio
+    [1, 2, -4]
+
+    """
+    def __new__(cls, p1, pt=None, direction_ratio=(), **kwargs):
+        if isinstance(p1, LinearEntity3D):
+            if pt is not None:
+                raise ValueError('If p1 is a LinearEntity, pt must be None')
+            p1, pt = p1.args
+        else:
+            p1 = Point(p1, dim=3)
+        if pt is not None and len(direction_ratio) == 0:
+            pt = Point(pt, dim=3)
+        elif len(direction_ratio) == 3 and pt is None:
+            pt = Point3D(p1.x + direction_ratio[0], p1.y + direction_ratio[1],
+                         p1.z + direction_ratio[2])
+        else:
+            raise ValueError(filldedent('''
+                A 2nd Point or keyword "direction_ratio" must be used.
+            '''))
+
+        return LinearEntity3D.__new__(cls, p1, pt, **kwargs)
+
+    @property
+    def xdirection(self):
+        """The x direction of the ray.
+
+        Positive infinity if the ray points in the positive x direction,
+        negative infinity if the ray points in the negative x direction,
+        or 0 if the ray is vertical.
+
+        See Also
+        ========
+
+        ydirection
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Ray3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, -1, 0)
+        >>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
+        >>> r1.xdirection
+        oo
+        >>> r2.xdirection
+        0
+
+        """
+        if self.p1.x < self.p2.x:
+            return S.Infinity
+        elif self.p1.x == self.p2.x:
+            return S.Zero
+        else:
+            return S.NegativeInfinity
+
+    @property
+    def ydirection(self):
+        """The y direction of the ray.
+
+        Positive infinity if the ray points in the positive y direction,
+        negative infinity if the ray points in the negative y direction,
+        or 0 if the ray is horizontal.
+
+        See Also
+        ========
+
+        xdirection
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Ray3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(-1, -1, -1), Point3D(-1, 0, 0)
+        >>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
+        >>> r1.ydirection
+        -oo
+        >>> r2.ydirection
+        0
+
+        """
+        if self.p1.y < self.p2.y:
+            return S.Infinity
+        elif self.p1.y == self.p2.y:
+            return S.Zero
+        else:
+            return S.NegativeInfinity
+
+    @property
+    def zdirection(self):
+        """The z direction of the ray.
+
+        Positive infinity if the ray points in the positive z direction,
+        negative infinity if the ray points in the negative z direction,
+        or 0 if the ray is horizontal.
+
+        See Also
+        ========
+
+        xdirection
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Ray3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(-1, -1, -1), Point3D(-1, 0, 0)
+        >>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
+        >>> r1.ydirection
+        -oo
+        >>> r2.ydirection
+        0
+        >>> r2.zdirection
+        0
+
+        """
+        if self.p1.z < self.p2.z:
+            return S.Infinity
+        elif self.p1.z == self.p2.z:
+            return S.Zero
+        else:
+            return S.NegativeInfinity
+
+
+class Segment3D(LinearEntity3D, Segment):
+    """A line segment in a 3D space.
+
+    Parameters
+    ==========
+
+    p1 : Point3D
+    p2 : Point3D
+
+    Attributes
+    ==========
+
+    length : number or SymPy expression
+    midpoint : Point3D
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point3D, Line3D
+
+    Examples
+    ========
+
+    >>> from sympy import Point3D, Segment3D
+    >>> Segment3D((1, 0, 0), (1, 1, 1)) # tuples are interpreted as pts
+    Segment3D(Point3D(1, 0, 0), Point3D(1, 1, 1))
+    >>> s = Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7)); s
+    Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7))
+    >>> s.points
+    (Point3D(4, 3, 9), Point3D(1, 1, 7))
+    >>> s.length
+    sqrt(17)
+    >>> s.midpoint
+    Point3D(5/2, 2, 8)
+
+    """
+    def __new__(cls, p1, p2, **kwargs):
+        p1 = Point(p1, dim=3)
+        p2 = Point(p2, dim=3)
+
+        if p1 == p2:
+            return p1
+
+        return LinearEntity3D.__new__(cls, p1, p2, **kwargs)

env-llmeval/lib/python3.10/site-packages/sympy/geometry/parabola.py

@@ -0,0 +1,422 @@
+"""Parabolic geometrical entity.
+
+Contains
+* Parabola
+
+"""
+
+from sympy.core import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import _symbol, symbols
+from sympy.geometry.entity import GeometryEntity, GeometrySet
+from sympy.geometry.point import Point, Point2D
+from sympy.geometry.line import Line, Line2D, Ray2D, Segment2D, LinearEntity3D
+from sympy.geometry.ellipse import Ellipse
+from sympy.functions import sign
+from sympy.simplify import simplify
+from sympy.solvers.solvers import solve
+
+
+class Parabola(GeometrySet):
+    """A parabolic GeometryEntity.
+
+    A parabola is declared with a point, that is called 'focus', and
+    a line, that is called 'directrix'.
+    Only vertical or horizontal parabolas are currently supported.
+
+    Parameters
+    ==========
+
+    focus : Point
+        Default value is Point(0, 0)
+    directrix : Line
+
+    Attributes
+    ==========
+
+    focus
+    directrix
+    axis of symmetry
+    focal length
+    p parameter
+    vertex
+    eccentricity
+
+    Raises
+    ======
+    ValueError
+        When `focus` is not a two dimensional point.
+        When `focus` is a point of directrix.
+    NotImplementedError
+        When `directrix` is neither horizontal nor vertical.
+
+    Examples
+    ========
+
+    >>> from sympy import Parabola, Point, Line
+    >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7,8)))
+    >>> p1.focus
+    Point2D(0, 0)
+    >>> p1.directrix
+    Line2D(Point2D(5, 8), Point2D(7, 8))
+
+    """
+
+    def __new__(cls, focus=None, directrix=None, **kwargs):
+
+        if focus:
+            focus = Point(focus, dim=2)
+        else:
+            focus = Point(0, 0)
+
+        directrix = Line(directrix)
+
+        if directrix.contains(focus):
+            raise ValueError('The focus must not be a point of directrix')
+
+        return GeometryEntity.__new__(cls, focus, directrix, **kwargs)
+
+    @property
+    def ambient_dimension(self):
+        """Returns the ambient dimension of parabola.
+
+        Returns
+        =======
+
+        ambient_dimension : integer
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> f1 = Point(0, 0)
+        >>> p1 = Parabola(f1, Line(Point(5, 8), Point(7, 8)))
+        >>> p1.ambient_dimension
+        2
+
+        """
+        return 2
+
+    @property
+    def axis_of_symmetry(self):
+        """Return the axis of symmetry of the parabola: a line
+        perpendicular to the directrix passing through the focus.
+
+        Returns
+        =======
+
+        axis_of_symmetry : Line
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+        >>> p1.axis_of_symmetry
+        Line2D(Point2D(0, 0), Point2D(0, 1))
+
+        """
+        return self.directrix.perpendicular_line(self.focus)
+
+    @property
+    def directrix(self):
+        """The directrix of the parabola.
+
+        Returns
+        =======
+
+        directrix : Line
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> l1 = Line(Point(5, 8), Point(7, 8))
+        >>> p1 = Parabola(Point(0, 0), l1)
+        >>> p1.directrix
+        Line2D(Point2D(5, 8), Point2D(7, 8))
+
+        """
+        return self.args[1]
+
+    @property
+    def eccentricity(self):
+        """The eccentricity of the parabola.
+
+        Returns
+        =======
+
+        eccentricity : number
+
+        A parabola may also be characterized as a conic section with an
+        eccentricity of 1. As a consequence of this, all parabolas are
+        similar, meaning that while they can be different sizes,
+        they are all the same shape.
+
+        See Also
+        ========
+
+        https://en.wikipedia.org/wiki/Parabola
+
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+        >>> p1.eccentricity
+        1
+
+        Notes
+        -----
+        The eccentricity for every Parabola is 1 by definition.
+
+        """
+        return S.One
+
+    def equation(self, x='x', y='y'):
+        """The equation of the parabola.
+
+        Parameters
+        ==========
+        x : str, optional
+            Label for the x-axis. Default value is 'x'.
+        y : str, optional
+            Label for the y-axis. Default value is 'y'.
+
+        Returns
+        =======
+        equation : SymPy expression
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+        >>> p1.equation()
+        -x**2 - 16*y + 64
+        >>> p1.equation('f')
+        -f**2 - 16*y + 64
+        >>> p1.equation(y='z')
+        -x**2 - 16*z + 64
+
+        """
+        x = _symbol(x, real=True)
+        y = _symbol(y, real=True)
+
+        m = self.directrix.slope
+        if m is S.Infinity:
+            t1 = 4 * (self.p_parameter) * (x - self.vertex.x)
+            t2 = (y - self.vertex.y)**2
+        elif m == 0:
+            t1 = 4 * (self.p_parameter) * (y - self.vertex.y)
+            t2 = (x - self.vertex.x)**2
+        else:
+            a, b = self.focus
+            c, d = self.directrix.coefficients[:2]
+            t1 = (x - a)**2 + (y - b)**2
+            t2 = self.directrix.equation(x, y)**2/(c**2 + d**2)
+        return t1 - t2
+
+    @property
+    def focal_length(self):
+        """The focal length of the parabola.
+
+        Returns
+        =======
+
+        focal_lenght : number or symbolic expression
+
+        Notes
+        =====
+
+        The distance between the vertex and the focus
+        (or the vertex and directrix), measured along the axis
+        of symmetry, is the "focal length".
+
+        See Also
+        ========
+
+        https://en.wikipedia.org/wiki/Parabola
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+        >>> p1.focal_length
+        4
+
+        """
+        distance = self.directrix.distance(self.focus)
+        focal_length = distance/2
+
+        return focal_length
+
+    @property
+    def focus(self):
+        """The focus of the parabola.
+
+        Returns
+        =======
+
+        focus : Point
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> f1 = Point(0, 0)
+        >>> p1 = Parabola(f1, Line(Point(5, 8), Point(7, 8)))
+        >>> p1.focus
+        Point2D(0, 0)
+
+        """
+        return self.args[0]
+
+    def intersection(self, o):
+        """The intersection of the parabola and another geometrical entity `o`.
+
+        Parameters
+        ==========
+
+        o : GeometryEntity, LinearEntity
+
+        Returns
+        =======
+
+        intersection : list of GeometryEntity objects
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Ellipse, Line, Segment
+        >>> p1 = Point(0,0)
+        >>> l1 = Line(Point(1, -2), Point(-1,-2))
+        >>> parabola1 = Parabola(p1, l1)
+        >>> parabola1.intersection(Ellipse(Point(0, 0), 2, 5))
+        [Point2D(-2, 0), Point2D(2, 0)]
+        >>> parabola1.intersection(Line(Point(-7, 3), Point(12, 3)))
+        [Point2D(-4, 3), Point2D(4, 3)]
+        >>> parabola1.intersection(Segment((-12, -65), (14, -68)))
+        []
+
+        """
+        x, y = symbols('x y', real=True)
+        parabola_eq = self.equation()
+        if isinstance(o, Parabola):
+            if o in self:
+                return [o]
+            else:
+                return list(ordered([Point(i) for i in solve(
+                    [parabola_eq, o.equation()], [x, y], set=True)[1]]))
+        elif isinstance(o, Point2D):
+            if simplify(parabola_eq.subs([(x, o._args[0]), (y, o._args[1])])) == 0:
+                return [o]
+            else:
+                return []
+        elif isinstance(o, (Segment2D, Ray2D)):
+            result = solve([parabola_eq,
+                Line2D(o.points[0], o.points[1]).equation()],
+                [x, y], set=True)[1]
+            return list(ordered([Point2D(i) for i in result if i in o]))
+        elif isinstance(o, (Line2D, Ellipse)):
+            return list(ordered([Point2D(i) for i in solve(
+                [parabola_eq, o.equation()], [x, y], set=True)[1]]))
+        elif isinstance(o, LinearEntity3D):
+            raise TypeError('Entity must be two dimensional, not three dimensional')
+        else:
+            raise TypeError('Wrong type of argument were put')
+
+    @property
+    def p_parameter(self):
+        """P is a parameter of parabola.
+
+        Returns
+        =======
+
+        p : number or symbolic expression
+
+        Notes
+        =====
+
+        The absolute value of p is the focal length. The sign on p tells
+        which way the parabola faces. Vertical parabolas that open up
+        and horizontal that open right, give a positive value for p.
+        Vertical parabolas that open down and horizontal that open left,
+        give a negative value for p.
+
+
+        See Also
+        ========
+
+        https://www.sparknotes.com/math/precalc/conicsections/section2/
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+        >>> p1.p_parameter
+        -4
+
+        """
+        m = self.directrix.slope
+        if m is S.Infinity:
+            x = self.directrix.coefficients[2]
+            p = sign(self.focus.args[0] + x)
+        elif m == 0:
+            y = self.directrix.coefficients[2]
+            p = sign(self.focus.args[1] + y)
+        else:
+            d = self.directrix.projection(self.focus)
+            p = sign(self.focus.x - d.x)
+        return p * self.focal_length
+
+    @property
+    def vertex(self):
+        """The vertex of the parabola.
+
+        Returns
+        =======
+
+        vertex : Point
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+        >>> p1.vertex
+        Point2D(0, 4)
+
+        """
+        focus = self.focus
+        m = self.directrix.slope
+        if m is S.Infinity:
+            vertex = Point(focus.args[0] - self.p_parameter, focus.args[1])
+        elif m == 0:
+            vertex = Point(focus.args[0], focus.args[1] - self.p_parameter)
+        else:
+            vertex = self.axis_of_symmetry.intersection(self)[0]
+        return vertex

env-llmeval/lib/python3.10/site-packages/sympy/geometry/plane.py

@@ -0,0 +1,884 @@
+"""Geometrical Planes.
+
+Contains
+========
+Plane
+
+"""
+
+from sympy.core import Dummy, Rational, S, Symbol
+from sympy.core.symbol import _symbol
+from sympy.functions.elementary.trigonometric import cos, sin, acos, asin, sqrt
+from .entity import GeometryEntity
+from .line import (Line, Ray, Segment, Line3D, LinearEntity, LinearEntity3D,
+                   Ray3D, Segment3D)
+from .point import Point, Point3D
+from sympy.matrices import Matrix
+from sympy.polys.polytools import cancel
+from sympy.solvers import solve, linsolve
+from sympy.utilities.iterables import uniq, is_sequence
+from sympy.utilities.misc import filldedent, func_name, Undecidable
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+import random
+
+
+x, y, z, t = [Dummy('plane_dummy') for i in range(4)]
+
+
+class Plane(GeometryEntity):
+    """
+    A plane is a flat, two-dimensional surface. A plane is the two-dimensional
+    analogue of a point (zero-dimensions), a line (one-dimension) and a solid
+    (three-dimensions). A plane can generally be constructed by two types of
+    inputs. They are three non-collinear points and a point and the plane's
+    normal vector.
+
+    Attributes
+    ==========
+
+    p1
+    normal_vector
+
+    Examples
+    ========
+
+    >>> from sympy import Plane, Point3D
+    >>> Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
+    Plane(Point3D(1, 1, 1), (-1, 2, -1))
+    >>> Plane((1, 1, 1), (2, 3, 4), (2, 2, 2))
+    Plane(Point3D(1, 1, 1), (-1, 2, -1))
+    >>> Plane(Point3D(1, 1, 1), normal_vector=(1,4,7))
+    Plane(Point3D(1, 1, 1), (1, 4, 7))
+
+    """
+    def __new__(cls, p1, a=None, b=None, **kwargs):
+        p1 = Point3D(p1, dim=3)
+        if a and b:
+            p2 = Point(a, dim=3)
+            p3 = Point(b, dim=3)
+            if Point3D.are_collinear(p1, p2, p3):
+                raise ValueError('Enter three non-collinear points')
+            a = p1.direction_ratio(p2)
+            b = p1.direction_ratio(p3)
+            normal_vector = tuple(Matrix(a).cross(Matrix(b)))
+        else:
+            a = kwargs.pop('normal_vector', a)
+            evaluate = kwargs.get('evaluate', True)
+            if is_sequence(a) and len(a) == 3:
+                normal_vector = Point3D(a).args if evaluate else a
+            else:
+                raise ValueError(filldedent('''
+                    Either provide 3 3D points or a point with a
+                    normal vector expressed as a sequence of length 3'''))
+            if all(coord.is_zero for coord in normal_vector):
+                raise ValueError('Normal vector cannot be zero vector')
+        return GeometryEntity.__new__(cls, p1, normal_vector, **kwargs)
+
+    def __contains__(self, o):
+        k = self.equation(x, y, z)
+        if isinstance(o, (LinearEntity, LinearEntity3D)):
+            d = Point3D(o.arbitrary_point(t))
+            e = k.subs([(x, d.x), (y, d.y), (z, d.z)])
+            return e.equals(0)
+        try:
+            o = Point(o, dim=3, strict=True)
+            d = k.xreplace(dict(zip((x, y, z), o.args)))
+            return d.equals(0)
+        except TypeError:
+            return False
+
+    def _eval_evalf(self, prec=15, **options):
+        pt, tup = self.args
+        dps = prec_to_dps(prec)
+        pt = pt.evalf(n=dps, **options)
+        tup = tuple([i.evalf(n=dps, **options) for i in tup])
+        return self.func(pt, normal_vector=tup, evaluate=False)
+
+    def angle_between(self, o):
+        """Angle between the plane and other geometric entity.
+
+        Parameters
+        ==========
+
+        LinearEntity3D, Plane.
+
+        Returns
+        =======
+
+        angle : angle in radians
+
+        Notes
+        =====
+
+        This method accepts only 3D entities as it's parameter, but if you want
+        to calculate the angle between a 2D entity and a plane you should
+        first convert to a 3D entity by projecting onto a desired plane and
+        then proceed to calculate the angle.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D, Plane
+        >>> a = Plane(Point3D(1, 2, 2), normal_vector=(1, 2, 3))
+        >>> b = Line3D(Point3D(1, 3, 4), Point3D(2, 2, 2))
+        >>> a.angle_between(b)
+        -asin(sqrt(21)/6)
+
+        """
+        if isinstance(o, LinearEntity3D):
+            a = Matrix(self.normal_vector)
+            b = Matrix(o.direction_ratio)
+            c = a.dot(b)
+            d = sqrt(sum([i**2 for i in self.normal_vector]))
+            e = sqrt(sum([i**2 for i in o.direction_ratio]))
+            return asin(c/(d*e))
+        if isinstance(o, Plane):
+            a = Matrix(self.normal_vector)
+            b = Matrix(o.normal_vector)
+            c = a.dot(b)
+            d = sqrt(sum([i**2 for i in self.normal_vector]))
+            e = sqrt(sum([i**2 for i in o.normal_vector]))
+            return acos(c/(d*e))
+
+
+    def arbitrary_point(self, u=None, v=None):
+        """ Returns an arbitrary point on the Plane. If given two
+        parameters, the point ranges over the entire plane. If given 1
+        or no parameters, returns a point with one parameter which,
+        when varying from 0 to 2*pi, moves the point in a circle of
+        radius 1 about p1 of the Plane.
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Ray
+        >>> from sympy.abc import u, v, t, r
+        >>> p = Plane((1, 1, 1), normal_vector=(1, 0, 0))
+        >>> p.arbitrary_point(u, v)
+        Point3D(1, u + 1, v + 1)
+        >>> p.arbitrary_point(t)
+        Point3D(1, cos(t) + 1, sin(t) + 1)
+
+        While arbitrary values of u and v can move the point anywhere in
+        the plane, the single-parameter point can be used to construct a
+        ray whose arbitrary point can be located at angle t and radius
+        r from p.p1:
+
+        >>> Ray(p.p1, _).arbitrary_point(r)
+        Point3D(1, r*cos(t) + 1, r*sin(t) + 1)
+
+        Returns
+        =======
+
+        Point3D
+
+        """
+        circle = v is None
+        if circle:
+            u = _symbol(u or 't', real=True)
+        else:
+            u = _symbol(u or 'u', real=True)
+            v = _symbol(v or 'v', real=True)
+        x, y, z = self.normal_vector
+        a, b, c = self.p1.args
+        # x1, y1, z1 is a nonzero vector parallel to the plane
+        if x.is_zero and y.is_zero:
+            x1, y1, z1 = S.One, S.Zero, S.Zero
+        else:
+            x1, y1, z1 = -y, x, S.Zero
+        # x2, y2, z2 is also parallel to the plane, and orthogonal to x1, y1, z1
+        x2, y2, z2 = tuple(Matrix((x, y, z)).cross(Matrix((x1, y1, z1))))
+        if circle:
+            x1, y1, z1 = (w/sqrt(x1**2 + y1**2 + z1**2) for w in (x1, y1, z1))
+            x2, y2, z2 = (w/sqrt(x2**2 + y2**2 + z2**2) for w in (x2, y2, z2))
+            p = Point3D(a + x1*cos(u) + x2*sin(u), \
+                        b + y1*cos(u) + y2*sin(u), \
+                        c + z1*cos(u) + z2*sin(u))
+        else:
+            p = Point3D(a + x1*u + x2*v, b + y1*u + y2*v, c + z1*u + z2*v)
+        return p
+
+
+    @staticmethod
+    def are_concurrent(*planes):
+        """Is a sequence of Planes concurrent?
+
+        Two or more Planes are concurrent if their intersections
+        are a common line.
+
+        Parameters
+        ==========
+
+        planes: list
+
+        Returns
+        =======
+
+        Boolean
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a = Plane(Point3D(5, 0, 0), normal_vector=(1, -1, 1))
+        >>> b = Plane(Point3D(0, -2, 0), normal_vector=(3, 1, 1))
+        >>> c = Plane(Point3D(0, -1, 0), normal_vector=(5, -1, 9))
+        >>> Plane.are_concurrent(a, b)
+        True
+        >>> Plane.are_concurrent(a, b, c)
+        False
+
+        """
+        planes = list(uniq(planes))
+        for i in planes:
+            if not isinstance(i, Plane):
+                raise ValueError('All objects should be Planes but got %s' % i.func)
+        if len(planes) < 2:
+            return False
+        planes = list(planes)
+        first = planes.pop(0)
+        sol = first.intersection(planes[0])
+        if sol == []:
+            return False
+        else:
+            line = sol[0]
+            for i in planes[1:]:
+                l = first.intersection(i)
+                if not l or l[0] not in line:
+                    return False
+            return True
+
+
+    def distance(self, o):
+        """Distance between the plane and another geometric entity.
+
+        Parameters
+        ==========
+
+        Point3D, LinearEntity3D, Plane.
+
+        Returns
+        =======
+
+        distance
+
+        Notes
+        =====
+
+        This method accepts only 3D entities as it's parameter, but if you want
+        to calculate the distance between a 2D entity and a plane you should
+        first convert to a 3D entity by projecting onto a desired plane and
+        then proceed to calculate the distance.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D, Plane
+        >>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 1, 1))
+        >>> b = Point3D(1, 2, 3)
+        >>> a.distance(b)
+        sqrt(3)
+        >>> c = Line3D(Point3D(2, 3, 1), Point3D(1, 2, 2))
+        >>> a.distance(c)
+        0
+
+        """
+        if self.intersection(o) != []:
+            return S.Zero
+
+        if isinstance(o, (Segment3D, Ray3D)):
+            a, b = o.p1, o.p2
+            pi, = self.intersection(Line3D(a, b))
+            if pi in o:
+                return self.distance(pi)
+            elif a in Segment3D(pi, b):
+                return self.distance(a)
+            else:
+                assert isinstance(o, Segment3D) is True
+                return self.distance(b)
+
+        # following code handles `Point3D`, `LinearEntity3D`, `Plane`
+        a = o if isinstance(o, Point3D) else o.p1
+        n = Point3D(self.normal_vector).unit
+        d = (a - self.p1).dot(n)
+        return abs(d)
+
+
+    def equals(self, o):
+        """
+        Returns True if self and o are the same mathematical entities.
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a = Plane(Point3D(1, 2, 3), normal_vector=(1, 1, 1))
+        >>> b = Plane(Point3D(1, 2, 3), normal_vector=(2, 2, 2))
+        >>> c = Plane(Point3D(1, 2, 3), normal_vector=(-1, 4, 6))
+        >>> a.equals(a)
+        True
+        >>> a.equals(b)
+        True
+        >>> a.equals(c)
+        False
+        """
+        if isinstance(o, Plane):
+            a = self.equation()
+            b = o.equation()
+            return cancel(a/b).is_constant()
+        else:
+            return False
+
+
+    def equation(self, x=None, y=None, z=None):
+        """The equation of the Plane.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Plane
+        >>> a = Plane(Point3D(1, 1, 2), Point3D(2, 4, 7), Point3D(3, 5, 1))
+        >>> a.equation()
+        -23*x + 11*y - 2*z + 16
+        >>> a = Plane(Point3D(1, 4, 2), normal_vector=(6, 6, 6))
+        >>> a.equation()
+        6*x + 6*y + 6*z - 42
+
+        """
+        x, y, z = [i if i else Symbol(j, real=True) for i, j in zip((x, y, z), 'xyz')]
+        a = Point3D(x, y, z)
+        b = self.p1.direction_ratio(a)
+        c = self.normal_vector
+        return (sum(i*j for i, j in zip(b, c)))
+
+
+    def intersection(self, o):
+        """ The intersection with other geometrical entity.
+
+        Parameters
+        ==========
+
+        Point, Point3D, LinearEntity, LinearEntity3D, Plane
+
+        Returns
+        =======
+
+        List
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D, Plane
+        >>> a = Plane(Point3D(1, 2, 3), normal_vector=(1, 1, 1))
+        >>> b = Point3D(1, 2, 3)
+        >>> a.intersection(b)
+        [Point3D(1, 2, 3)]
+        >>> c = Line3D(Point3D(1, 4, 7), Point3D(2, 2, 2))
+        >>> a.intersection(c)
+        [Point3D(2, 2, 2)]
+        >>> d = Plane(Point3D(6, 0, 0), normal_vector=(2, -5, 3))
+        >>> e = Plane(Point3D(2, 0, 0), normal_vector=(3, 4, -3))
+        >>> d.intersection(e)
+        [Line3D(Point3D(78/23, -24/23, 0), Point3D(147/23, 321/23, 23))]
+
+        """
+        if not isinstance(o, GeometryEntity):
+            o = Point(o, dim=3)
+        if isinstance(o, Point):
+            if o in self:
+                return [o]
+            else:
+                return []
+        if isinstance(o, (LinearEntity, LinearEntity3D)):
+            # recast to 3D
+            p1, p2 = o.p1, o.p2
+            if isinstance(o, Segment):
+                o = Segment3D(p1, p2)
+            elif isinstance(o, Ray):
+                o = Ray3D(p1, p2)
+            elif isinstance(o, Line):
+                o = Line3D(p1, p2)
+            else:
+                raise ValueError('unhandled linear entity: %s' % o.func)
+            if o in self:
+                return [o]
+            else:
+                a = Point3D(o.arbitrary_point(t))
+                p1, n = self.p1, Point3D(self.normal_vector)
+
+                # TODO: Replace solve with solveset, when this line is tested
+                c = solve((a - p1).dot(n), t)
+                if not c:
+                    return []
+                else:
+                    c = [i for i in c if i.is_real is not False]
+                    if len(c) > 1:
+                        c = [i for i in c if i.is_real]
+                    if len(c) != 1:
+                        raise Undecidable("not sure which point is real")
+                    p = a.subs(t, c[0])
+                    if p not in o:
+                        return []  # e.g. a segment might not intersect a plane
+                    return [p]
+        if isinstance(o, Plane):
+            if self.equals(o):
+                return [self]
+            if self.is_parallel(o):
+                return []
+            else:
+                x, y, z = map(Dummy, 'xyz')
+                a, b = Matrix([self.normal_vector]), Matrix([o.normal_vector])
+                c = list(a.cross(b))
+                d = self.equation(x, y, z)
+                e = o.equation(x, y, z)
+                result = list(linsolve([d, e], x, y, z))[0]
+                for i in (x, y, z): result = result.subs(i, 0)
+                return [Line3D(Point3D(result), direction_ratio=c)]
+
+
+    def is_coplanar(self, o):
+        """ Returns True if `o` is coplanar with self, else False.
+
+        Examples
+        ========
+
+        >>> from sympy import Plane
+        >>> o = (0, 0, 0)
+        >>> p = Plane(o, (1, 1, 1))
+        >>> p2 = Plane(o, (2, 2, 2))
+        >>> p == p2
+        False
+        >>> p.is_coplanar(p2)
+        True
+        """
+        if isinstance(o, Plane):
+            return not cancel(self.equation(x, y, z)/o.equation(x, y, z)).has(x, y, z)
+        if isinstance(o, Point3D):
+            return o in self
+        elif isinstance(o, LinearEntity3D):
+            return all(i in self for i in self)
+        elif isinstance(o, GeometryEntity):  # XXX should only be handling 2D objects now
+            return all(i == 0 for i in self.normal_vector[:2])
+
+
+    def is_parallel(self, l):
+        """Is the given geometric entity parallel to the plane?
+
+        Parameters
+        ==========
+
+        LinearEntity3D or Plane
+
+        Returns
+        =======
+
+        Boolean
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
+        >>> b = Plane(Point3D(3,1,3), normal_vector=(4, 8, 12))
+        >>> a.is_parallel(b)
+        True
+
+        """
+        if isinstance(l, LinearEntity3D):
+            a = l.direction_ratio
+            b = self.normal_vector
+            c = sum([i*j for i, j in zip(a, b)])
+            if c == 0:
+                return True
+            else:
+                return False
+        elif isinstance(l, Plane):
+            a = Matrix(l.normal_vector)
+            b = Matrix(self.normal_vector)
+            if a.cross(b).is_zero_matrix:
+                return True
+            else:
+                return False
+
+
+    def is_perpendicular(self, l):
+        """Is the given geometric entity perpendicualar to the given plane?
+
+        Parameters
+        ==========
+
+        LinearEntity3D or Plane
+
+        Returns
+        =======
+
+        Boolean
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
+        >>> b = Plane(Point3D(2, 2, 2), normal_vector=(-1, 2, -1))
+        >>> a.is_perpendicular(b)
+        True
+
+        """
+        if isinstance(l, LinearEntity3D):
+            a = Matrix(l.direction_ratio)
+            b = Matrix(self.normal_vector)
+            if a.cross(b).is_zero_matrix:
+                return True
+            else:
+                return False
+        elif isinstance(l, Plane):
+           a = Matrix(l.normal_vector)
+           b = Matrix(self.normal_vector)
+           if a.dot(b) == 0:
+               return True
+           else:
+               return False
+        else:
+            return False
+
+    @property
+    def normal_vector(self):
+        """Normal vector of the given plane.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Plane
+        >>> a = Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
+        >>> a.normal_vector
+        (-1, 2, -1)
+        >>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 4, 7))
+        >>> a.normal_vector
+        (1, 4, 7)
+
+        """
+        return self.args[1]
+
+    @property
+    def p1(self):
+        """The only defining point of the plane. Others can be obtained from the
+        arbitrary_point method.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point3D
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Plane
+        >>> a = Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
+        >>> a.p1
+        Point3D(1, 1, 1)
+
+        """
+        return self.args[0]
+
+    def parallel_plane(self, pt):
+        """
+        Plane parallel to the given plane and passing through the point pt.
+
+        Parameters
+        ==========
+
+        pt: Point3D
+
+        Returns
+        =======
+
+        Plane
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a = Plane(Point3D(1, 4, 6), normal_vector=(2, 4, 6))
+        >>> a.parallel_plane(Point3D(2, 3, 5))
+        Plane(Point3D(2, 3, 5), (2, 4, 6))
+
+        """
+        a = self.normal_vector
+        return Plane(pt, normal_vector=a)
+
+    def perpendicular_line(self, pt):
+        """A line perpendicular to the given plane.
+
+        Parameters
+        ==========
+
+        pt: Point3D
+
+        Returns
+        =======
+
+        Line3D
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
+        >>> a.perpendicular_line(Point3D(9, 8, 7))
+        Line3D(Point3D(9, 8, 7), Point3D(11, 12, 13))
+
+        """
+        a = self.normal_vector
+        return Line3D(pt, direction_ratio=a)
+
+    def perpendicular_plane(self, *pts):
+        """
+        Return a perpendicular passing through the given points. If the
+        direction ratio between the points is the same as the Plane's normal
+        vector then, to select from the infinite number of possible planes,
+        a third point will be chosen on the z-axis (or the y-axis
+        if the normal vector is already parallel to the z-axis). If less than
+        two points are given they will be supplied as follows: if no point is
+        given then pt1 will be self.p1; if a second point is not given it will
+        be a point through pt1 on a line parallel to the z-axis (if the normal
+        is not already the z-axis, otherwise on the line parallel to the
+        y-axis).
+
+        Parameters
+        ==========
+
+        pts: 0, 1 or 2 Point3D
+
+        Returns
+        =======
+
+        Plane
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a, b = Point3D(0, 0, 0), Point3D(0, 1, 0)
+        >>> Z = (0, 0, 1)
+        >>> p = Plane(a, normal_vector=Z)
+        >>> p.perpendicular_plane(a, b)
+        Plane(Point3D(0, 0, 0), (1, 0, 0))
+        """
+        if len(pts) > 2:
+            raise ValueError('No more than 2 pts should be provided.')
+
+        pts = list(pts)
+        if len(pts) == 0:
+            pts.append(self.p1)
+        if len(pts) == 1:
+            x, y, z = self.normal_vector
+            if x == y == 0:
+                dir = (0, 1, 0)
+            else:
+                dir = (0, 0, 1)
+            pts.append(pts[0] + Point3D(*dir))
+
+        p1, p2 = [Point(i, dim=3) for i in pts]
+        l = Line3D(p1, p2)
+        n = Line3D(p1, direction_ratio=self.normal_vector)
+        if l in n:  # XXX should an error be raised instead?
+            # there are infinitely many perpendicular planes;
+            x, y, z = self.normal_vector
+            if x == y == 0:
+                # the z axis is the normal so pick a pt on the y-axis
+                p3 = Point3D(0, 1, 0)  # case 1
+            else:
+                # else pick a pt on the z axis
+                p3 = Point3D(0, 0, 1)  # case 2
+            # in case that point is already given, move it a bit
+            if p3 in l:
+                p3 *= 2  # case 3
+        else:
+            p3 = p1 + Point3D(*self.normal_vector)  # case 4
+        return Plane(p1, p2, p3)
+
+    def projection_line(self, line):
+        """Project the given line onto the plane through the normal plane
+        containing the line.
+
+        Parameters
+        ==========
+
+        LinearEntity or LinearEntity3D
+
+        Returns
+        =======
+
+        Point3D, Line3D, Ray3D or Segment3D
+
+        Notes
+        =====
+
+        For the interaction between 2D and 3D lines(segments, rays), you should
+        convert the line to 3D by using this method. For example for finding the
+        intersection between a 2D and a 3D line, convert the 2D line to a 3D line
+        by projecting it on a required plane and then proceed to find the
+        intersection between those lines.
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Line, Line3D, Point3D
+        >>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 1, 1))
+        >>> b = Line(Point3D(1, 1), Point3D(2, 2))
+        >>> a.projection_line(b)
+        Line3D(Point3D(4/3, 4/3, 1/3), Point3D(5/3, 5/3, -1/3))
+        >>> c = Line3D(Point3D(1, 1, 1), Point3D(2, 2, 2))
+        >>> a.projection_line(c)
+        Point3D(1, 1, 1)
+
+        """
+        if not isinstance(line, (LinearEntity, LinearEntity3D)):
+            raise NotImplementedError('Enter a linear entity only')
+        a, b = self.projection(line.p1), self.projection(line.p2)
+        if a == b:
+            # projection does not imply intersection so for
+            # this case (line parallel to plane's normal) we
+            # return the projection point
+            return a
+        if isinstance(line, (Line, Line3D)):
+            return Line3D(a, b)
+        if isinstance(line, (Ray, Ray3D)):
+            return Ray3D(a, b)
+        if isinstance(line, (Segment, Segment3D)):
+            return Segment3D(a, b)
+
+    def projection(self, pt):
+        """Project the given point onto the plane along the plane normal.
+
+        Parameters
+        ==========
+
+        Point or Point3D
+
+        Returns
+        =======
+
+        Point3D
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> A = Plane(Point3D(1, 1, 2), normal_vector=(1, 1, 1))
+
+        The projection is along the normal vector direction, not the z
+        axis, so (1, 1) does not project to (1, 1, 2) on the plane A:
+
+        >>> b = Point3D(1, 1)
+        >>> A.projection(b)
+        Point3D(5/3, 5/3, 2/3)
+        >>> _ in A
+        True
+
+        But the point (1, 1, 2) projects to (1, 1) on the XY-plane:
+
+        >>> XY = Plane((0, 0, 0), (0, 0, 1))
+        >>> XY.projection((1, 1, 2))
+        Point3D(1, 1, 0)
+        """
+        rv = Point(pt, dim=3)
+        if rv in self:
+            return rv
+        return self.intersection(Line3D(rv, rv + Point3D(self.normal_vector)))[0]
+
+    def random_point(self, seed=None):
+        """ Returns a random point on the Plane.
+
+        Returns
+        =======
+
+        Point3D
+
+        Examples
+        ========
+
+        >>> from sympy import Plane
+        >>> p = Plane((1, 0, 0), normal_vector=(0, 1, 0))
+        >>> r = p.random_point(seed=42)  # seed value is optional
+        >>> r.n(3)
+        Point3D(2.29, 0, -1.35)
+
+        The random point can be moved to lie on the circle of radius
+        1 centered on p1:
+
+        >>> c = p.p1 + (r - p.p1).unit
+        >>> c.distance(p.p1).equals(1)
+        True
+        """
+        if seed is not None:
+            rng = random.Random(seed)
+        else:
+            rng = random
+        params = {
+            x: 2*Rational(rng.gauss(0, 1)) - 1,
+            y: 2*Rational(rng.gauss(0, 1)) - 1}
+        return self.arbitrary_point(x, y).subs(params)
+
+    def parameter_value(self, other, u, v=None):
+        """Return the parameter(s) corresponding to the given point.
+
+        Examples
+        ========
+
+        >>> from sympy import pi, Plane
+        >>> from sympy.abc import t, u, v
+        >>> p = Plane((2, 0, 0), (0, 0, 1), (0, 1, 0))
+
+        By default, the parameter value returned defines a point
+        that is a distance of 1 from the Plane's p1 value and
+        in line with the given point:
+
+        >>> on_circle = p.arbitrary_point(t).subs(t, pi/4)
+        >>> on_circle.distance(p.p1)
+        1
+        >>> p.parameter_value(on_circle, t)
+        {t: pi/4}
+
+        Moving the point twice as far from p1 does not change
+        the parameter value:
+
+        >>> off_circle = p.p1 + (on_circle - p.p1)*2
+        >>> off_circle.distance(p.p1)
+        2
+        >>> p.parameter_value(off_circle, t)
+        {t: pi/4}
+
+        If the 2-value parameter is desired, supply the two
+        parameter symbols and a replacement dictionary will
+        be returned:
+
+        >>> p.parameter_value(on_circle, u, v)
+        {u: sqrt(10)/10, v: sqrt(10)/30}
+        >>> p.parameter_value(off_circle, u, v)
+        {u: sqrt(10)/5, v: sqrt(10)/15}
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if not isinstance(other, Point):
+            raise ValueError("other must be a point")
+        if other == self.p1:
+            return other
+        if isinstance(u, Symbol) and v is None:
+            delta = self.arbitrary_point(u) - self.p1
+            eq = delta - (other - self.p1).unit
+            sol = solve(eq, u, dict=True)
+        elif isinstance(u, Symbol) and isinstance(v, Symbol):
+            pt = self.arbitrary_point(u, v)
+            sol = solve(pt - other, (u, v), dict=True)
+        else:
+            raise ValueError('expecting 1 or 2 symbols')
+        if not sol:
+            raise ValueError("Given point is not on %s" % func_name(self))
+        return sol[0]  # {t: tval} or {u: uval, v: vval}
+
+    @property
+    def ambient_dimension(self):
+        return self.p1.ambient_dimension

env-llmeval/lib/python3.10/site-packages/sympy/geometry/point.py

@@ -0,0 +1,1378 @@
+"""Geometrical Points.
+
+Contains
+========
+Point
+Point2D
+Point3D
+
+When methods of Point require 1 or more points as arguments, they
+can be passed as a sequence of coordinates or Points:
+
+>>> from sympy import Point
+>>> Point(1, 1).is_collinear((2, 2), (3, 4))
+False
+>>> Point(1, 1).is_collinear(Point(2, 2), Point(3, 4))
+False
+
+"""
+
+import warnings
+
+from sympy.core import S, sympify, Expr
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.numbers import Float
+from sympy.core.parameters import global_parameters
+from sympy.simplify import nsimplify, simplify
+from sympy.geometry.exceptions import GeometryError
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.complexes import im
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.matrices import Matrix
+from sympy.matrices.expressions import Transpose
+from sympy.utilities.iterables import uniq, is_sequence
+from sympy.utilities.misc import filldedent, func_name, Undecidable
+
+from .entity import GeometryEntity
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+class Point(GeometryEntity):
+    """A point in a n-dimensional Euclidean space.
+
+    Parameters
+    ==========
+
+    coords : sequence of n-coordinate values. In the special
+        case where n=2 or 3, a Point2D or Point3D will be created
+        as appropriate.
+    evaluate : if `True` (default), all floats are turn into
+        exact types.
+    dim : number of coordinates the point should have.  If coordinates
+        are unspecified, they are padded with zeros.
+    on_morph : indicates what should happen when the number of
+        coordinates of a point need to be changed by adding or
+        removing zeros.  Possible values are `'warn'`, `'error'`, or
+        `ignore` (default).  No warning or error is given when `*args`
+        is empty and `dim` is given. An error is always raised when
+        trying to remove nonzero coordinates.
+
+
+    Attributes
+    ==========
+
+    length
+    origin: A `Point` representing the origin of the
+        appropriately-dimensioned space.
+
+    Raises
+    ======
+
+    TypeError : When instantiating with anything but a Point or sequence
+    ValueError : when instantiating with a sequence with length < 2 or
+        when trying to reduce dimensions if keyword `on_morph='error'` is
+        set.
+
+    See Also
+    ========
+
+    sympy.geometry.line.Segment : Connects two Points
+
+    Examples
+    ========
+
+    >>> from sympy import Point
+    >>> from sympy.abc import x
+    >>> Point(1, 2, 3)
+    Point3D(1, 2, 3)
+    >>> Point([1, 2])
+    Point2D(1, 2)
+    >>> Point(0, x)
+    Point2D(0, x)
+    >>> Point(dim=4)
+    Point(0, 0, 0, 0)
+
+    Floats are automatically converted to Rational unless the
+    evaluate flag is False:
+
+    >>> Point(0.5, 0.25)
+    Point2D(1/2, 1/4)
+    >>> Point(0.5, 0.25, evaluate=False)
+    Point2D(0.5, 0.25)
+
+    """
+
+    is_Point = True
+
+    def __new__(cls, *args, **kwargs):
+        evaluate = kwargs.get('evaluate', global_parameters.evaluate)
+        on_morph = kwargs.get('on_morph', 'ignore')
+
+        # unpack into coords
+        coords = args[0] if len(args) == 1 else args
+
+        # check args and handle quickly handle Point instances
+        if isinstance(coords, Point):
+            # even if we're mutating the dimension of a point, we
+            # don't reevaluate its coordinates
+            evaluate = False
+            if len(coords) == kwargs.get('dim', len(coords)):
+                return coords
+
+        if not is_sequence(coords):
+            raise TypeError(filldedent('''
+                Expecting sequence of coordinates, not `{}`'''
+                                       .format(func_name(coords))))
+        # A point where only `dim` is specified is initialized
+        # to zeros.
+        if len(coords) == 0 and kwargs.get('dim', None):
+            coords = (S.Zero,)*kwargs.get('dim')
+
+        coords = Tuple(*coords)
+        dim = kwargs.get('dim', len(coords))
+
+        if len(coords) < 2:
+            raise ValueError(filldedent('''
+                Point requires 2 or more coordinates or
+                keyword `dim` > 1.'''))
+        if len(coords) != dim:
+            message = ("Dimension of {} needs to be changed "
+                       "from {} to {}.").format(coords, len(coords), dim)
+            if on_morph == 'ignore':
+                pass
+            elif on_morph == "error":
+                raise ValueError(message)
+            elif on_morph == 'warn':
+                warnings.warn(message, stacklevel=2)
+            else:
+                raise ValueError(filldedent('''
+                        on_morph value should be 'error',
+                        'warn' or 'ignore'.'''))
+        if any(coords[dim:]):
+            raise ValueError('Nonzero coordinates cannot be removed.')
+        if any(a.is_number and im(a).is_zero is False for a in coords):
+            raise ValueError('Imaginary coordinates are not permitted.')
+        if not all(isinstance(a, Expr) for a in coords):
+            raise TypeError('Coordinates must be valid SymPy expressions.')
+
+        # pad with zeros appropriately
+        coords = coords[:dim] + (S.Zero,)*(dim - len(coords))
+
+        # Turn any Floats into rationals and simplify
+        # any expressions before we instantiate
+        if evaluate:
+            coords = coords.xreplace({
+                f: simplify(nsimplify(f, rational=True))
+                 for f in coords.atoms(Float)})
+
+        # return 2D or 3D instances
+        if len(coords) == 2:
+            kwargs['_nocheck'] = True
+            return Point2D(*coords, **kwargs)
+        elif len(coords) == 3:
+            kwargs['_nocheck'] = True
+            return Point3D(*coords, **kwargs)
+
+        # the general Point
+        return GeometryEntity.__new__(cls, *coords)
+
+    def __abs__(self):
+        """Returns the distance between this point and the origin."""
+        origin = Point([0]*len(self))
+        return Point.distance(origin, self)
+
+    def __add__(self, other):
+        """Add other to self by incrementing self's coordinates by
+        those of other.
+
+        Notes
+        =====
+
+        >>> from sympy import Point
+
+        When sequences of coordinates are passed to Point methods, they
+        are converted to a Point internally. This __add__ method does
+        not do that so if floating point values are used, a floating
+        point result (in terms of SymPy Floats) will be returned.
+
+        >>> Point(1, 2) + (.1, .2)
+        Point2D(1.1, 2.2)
+
+        If this is not desired, the `translate` method can be used or
+        another Point can be added:
+
+        >>> Point(1, 2).translate(.1, .2)
+        Point2D(11/10, 11/5)
+        >>> Point(1, 2) + Point(.1, .2)
+        Point2D(11/10, 11/5)
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.translate
+
+        """
+        try:
+            s, o = Point._normalize_dimension(self, Point(other, evaluate=False))
+        except TypeError:
+            raise GeometryError("Don't know how to add {} and a Point object".format(other))
+
+        coords = [simplify(a + b) for a, b in zip(s, o)]
+        return Point(coords, evaluate=False)
+
+    def __contains__(self, item):
+        return item in self.args
+
+    def __truediv__(self, divisor):
+        """Divide point's coordinates by a factor."""
+        divisor = sympify(divisor)
+        coords = [simplify(x/divisor) for x in self.args]
+        return Point(coords, evaluate=False)
+
+    def __eq__(self, other):
+        if not isinstance(other, Point) or len(self.args) != len(other.args):
+            return False
+        return self.args == other.args
+
+    def __getitem__(self, key):
+        return self.args[key]
+
+    def __hash__(self):
+        return hash(self.args)
+
+    def __iter__(self):
+        return self.args.__iter__()
+
+    def __len__(self):
+        return len(self.args)
+
+    def __mul__(self, factor):
+        """Multiply point's coordinates by a factor.
+
+        Notes
+        =====
+
+        >>> from sympy import Point
+
+        When multiplying a Point by a floating point number,
+        the coordinates of the Point will be changed to Floats:
+
+        >>> Point(1, 2)*0.1
+        Point2D(0.1, 0.2)
+
+        If this is not desired, the `scale` method can be used or
+        else only multiply or divide by integers:
+
+        >>> Point(1, 2).scale(1.1, 1.1)
+        Point2D(11/10, 11/5)
+        >>> Point(1, 2)*11/10
+        Point2D(11/10, 11/5)
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.scale
+        """
+        factor = sympify(factor)
+        coords = [simplify(x*factor) for x in self.args]
+        return Point(coords, evaluate=False)
+
+    def __rmul__(self, factor):
+        """Multiply a factor by point's coordinates."""
+        return self.__mul__(factor)
+
+    def __neg__(self):
+        """Negate the point."""
+        coords = [-x for x in self.args]
+        return Point(coords, evaluate=False)
+
+    def __sub__(self, other):
+        """Subtract two points, or subtract a factor from this point's
+        coordinates."""
+        return self + [-x for x in other]
+
+    @classmethod
+    def _normalize_dimension(cls, *points, **kwargs):
+        """Ensure that points have the same dimension.
+        By default `on_morph='warn'` is passed to the
+        `Point` constructor."""
+        # if we have a built-in ambient dimension, use it
+        dim = getattr(cls, '_ambient_dimension', None)
+        # override if we specified it
+        dim = kwargs.get('dim', dim)
+        # if no dim was given, use the highest dimensional point
+        if dim is None:
+            dim = max(i.ambient_dimension for i in points)
+        if all(i.ambient_dimension == dim for i in points):
+            return list(points)
+        kwargs['dim'] = dim
+        kwargs['on_morph'] = kwargs.get('on_morph', 'warn')
+        return [Point(i, **kwargs) for i in points]
+
+    @staticmethod
+    def affine_rank(*args):
+        """The affine rank of a set of points is the dimension
+        of the smallest affine space containing all the points.
+        For example, if the points lie on a line (and are not all
+        the same) their affine rank is 1.  If the points lie on a plane
+        but not a line, their affine rank is 2.  By convention, the empty
+        set has affine rank -1."""
+
+        if len(args) == 0:
+            return -1
+        # make sure we're genuinely points
+        # and translate every point to the origin
+        points = Point._normalize_dimension(*[Point(i) for i in args])
+        origin = points[0]
+        points = [i - origin for i in points[1:]]
+
+        m = Matrix([i.args for i in points])
+        # XXX fragile -- what is a better way?
+        return m.rank(iszerofunc = lambda x:
+            abs(x.n(2)) < 1e-12 if x.is_number else x.is_zero)
+
+    @property
+    def ambient_dimension(self):
+        """Number of components this point has."""
+        return getattr(self, '_ambient_dimension', len(self))
+
+    @classmethod
+    def are_coplanar(cls, *points):
+        """Return True if there exists a plane in which all the points
+        lie.  A trivial True value is returned if `len(points) < 3` or
+        all Points are 2-dimensional.
+
+        Parameters
+        ==========
+
+        A set of points
+
+        Raises
+        ======
+
+        ValueError : if less than 3 unique points are given
+
+        Returns
+        =======
+
+        boolean
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p1 = Point3D(1, 2, 2)
+        >>> p2 = Point3D(2, 7, 2)
+        >>> p3 = Point3D(0, 0, 2)
+        >>> p4 = Point3D(1, 1, 2)
+        >>> Point3D.are_coplanar(p1, p2, p3, p4)
+        True
+        >>> p5 = Point3D(0, 1, 3)
+        >>> Point3D.are_coplanar(p1, p2, p3, p5)
+        False
+
+        """
+        if len(points) <= 1:
+            return True
+
+        points = cls._normalize_dimension(*[Point(i) for i in points])
+        # quick exit if we are in 2D
+        if points[0].ambient_dimension == 2:
+            return True
+        points = list(uniq(points))
+        return Point.affine_rank(*points) <= 2
+
+    def distance(self, other):
+        """The Euclidean distance between self and another GeometricEntity.
+
+        Returns
+        =======
+
+        distance : number or symbolic expression.
+
+        Raises
+        ======
+
+        TypeError : if other is not recognized as a GeometricEntity or is a
+                    GeometricEntity for which distance is not defined.
+
+        See Also
+        ========
+
+        sympy.geometry.line.Segment.length
+        sympy.geometry.point.Point.taxicab_distance
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(1, 1), Point(4, 5)
+        >>> l = Line((3, 1), (2, 2))
+        >>> p1.distance(p2)
+        5
+        >>> p1.distance(l)
+        sqrt(2)
+
+        The computed distance may be symbolic, too:
+
+        >>> from sympy.abc import x, y
+        >>> p3 = Point(x, y)
+        >>> p3.distance((0, 0))
+        sqrt(x**2 + y**2)
+
+        """
+        if not isinstance(other, GeometryEntity):
+            try:
+                other = Point(other, dim=self.ambient_dimension)
+            except TypeError:
+                raise TypeError("not recognized as a GeometricEntity: %s" % type(other))
+        if isinstance(other, Point):
+            s, p = Point._normalize_dimension(self, Point(other))
+            return sqrt(Add(*((a - b)**2 for a, b in zip(s, p))))
+        distance = getattr(other, 'distance', None)
+        if distance is None:
+            raise TypeError("distance between Point and %s is not defined" % type(other))
+        return distance(self)
+
+    def dot(self, p):
+        """Return dot product of self with another Point."""
+        if not is_sequence(p):
+            p = Point(p)  # raise the error via Point
+        return Add(*(a*b for a, b in zip(self, p)))
+
+    def equals(self, other):
+        """Returns whether the coordinates of self and other agree."""
+        # a point is equal to another point if all its components are equal
+        if not isinstance(other, Point) or len(self) != len(other):
+            return False
+        return all(a.equals(b) for a, b in zip(self, other))
+
+    def _eval_evalf(self, prec=15, **options):
+        """Evaluate the coordinates of the point.
+
+        This method will, where possible, create and return a new Point
+        where the coordinates are evaluated as floating point numbers to
+        the precision indicated (default=15).
+
+        Parameters
+        ==========
+
+        prec : int
+
+        Returns
+        =======
+
+        point : Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Rational
+        >>> p1 = Point(Rational(1, 2), Rational(3, 2))
+        >>> p1
+        Point2D(1/2, 3/2)
+        >>> p1.evalf()
+        Point2D(0.5, 1.5)
+
+        """
+        dps = prec_to_dps(prec)
+        coords = [x.evalf(n=dps, **options) for x in self.args]
+        return Point(*coords, evaluate=False)
+
+    def intersection(self, other):
+        """The intersection between this point and another GeometryEntity.
+
+        Parameters
+        ==========
+
+        other : GeometryEntity or sequence of coordinates
+
+        Returns
+        =======
+
+        intersection : list of Points
+
+        Notes
+        =====
+
+        The return value will either be an empty list if there is no
+        intersection, otherwise it will contain this point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, 0)
+        >>> p1.intersection(p2)
+        []
+        >>> p1.intersection(p3)
+        [Point2D(0, 0)]
+
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other)
+        if isinstance(other, Point):
+            if self == other:
+                return [self]
+            p1, p2 = Point._normalize_dimension(self, other)
+            if p1 == self and p1 == p2:
+                return [self]
+            return []
+        return other.intersection(self)
+
+    def is_collinear(self, *args):
+        """Returns `True` if there exists a line
+        that contains `self` and `points`.  Returns `False` otherwise.
+        A trivially True value is returned if no points are given.
+
+        Parameters
+        ==========
+
+        args : sequence of Points
+
+        Returns
+        =======
+
+        is_collinear : boolean
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+        >>> from sympy.abc import x
+        >>> p1, p2 = Point(0, 0), Point(1, 1)
+        >>> p3, p4, p5 = Point(2, 2), Point(x, x), Point(1, 2)
+        >>> Point.is_collinear(p1, p2, p3, p4)
+        True
+        >>> Point.is_collinear(p1, p2, p3, p5)
+        False
+
+        """
+        points = (self,) + args
+        points = Point._normalize_dimension(*[Point(i) for i in points])
+        points = list(uniq(points))
+        return Point.affine_rank(*points) <= 1
+
+    def is_concyclic(self, *args):
+        """Do `self` and the given sequence of points lie in a circle?
+
+        Returns True if the set of points are concyclic and
+        False otherwise. A trivial value of True is returned
+        if there are fewer than 2 other points.
+
+        Parameters
+        ==========
+
+        args : sequence of Points
+
+        Returns
+        =======
+
+        is_concyclic : boolean
+
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+
+        Define 4 points that are on the unit circle:
+
+        >>> p1, p2, p3, p4 = Point(1, 0), (0, 1), (-1, 0), (0, -1)
+
+        >>> p1.is_concyclic() == p1.is_concyclic(p2, p3, p4) == True
+        True
+
+        Define a point not on that circle:
+
+        >>> p = Point(1, 1)
+
+        >>> p.is_concyclic(p1, p2, p3)
+        False
+
+        """
+        points = (self,) + args
+        points = Point._normalize_dimension(*[Point(i) for i in points])
+        points = list(uniq(points))
+        if not Point.affine_rank(*points) <= 2:
+            return False
+        origin = points[0]
+        points = [p - origin for p in points]
+        # points are concyclic if they are coplanar and
+        # there is a point c so that ||p_i-c|| == ||p_j-c|| for all
+        # i and j.  Rearranging this equation gives us the following
+        # condition: the matrix `mat` must not a pivot in the last
+        # column.
+        mat = Matrix([list(i) + [i.dot(i)] for i in points])
+        rref, pivots = mat.rref()
+        if len(origin) not in pivots:
+            return True
+        return False
+
+    @property
+    def is_nonzero(self):
+        """True if any coordinate is nonzero, False if every coordinate is zero,
+        and None if it cannot be determined."""
+        is_zero = self.is_zero
+        if is_zero is None:
+            return None
+        return not is_zero
+
+    def is_scalar_multiple(self, p):
+        """Returns whether each coordinate of `self` is a scalar
+        multiple of the corresponding coordinate in point p.
+        """
+        s, o = Point._normalize_dimension(self, Point(p))
+        # 2d points happen a lot, so optimize this function call
+        if s.ambient_dimension == 2:
+            (x1, y1), (x2, y2) = s.args, o.args
+            rv = (x1*y2 - x2*y1).equals(0)
+            if rv is None:
+                raise Undecidable(filldedent(
+                    '''Cannot determine if %s is a scalar multiple of
+                    %s''' % (s, o)))
+
+        # if the vectors p1 and p2 are linearly dependent, then they must
+        # be scalar multiples of each other
+        m = Matrix([s.args, o.args])
+        return m.rank() < 2
+
+    @property
+    def is_zero(self):
+        """True if every coordinate is zero, False if any coordinate is not zero,
+        and None if it cannot be determined."""
+        nonzero = [x.is_nonzero for x in self.args]
+        if any(nonzero):
+            return False
+        if any(x is None for x in nonzero):
+            return None
+        return True
+
+    @property
+    def length(self):
+        """
+        Treating a Point as a Line, this returns 0 for the length of a Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+        >>> p = Point(0, 1)
+        >>> p.length
+        0
+        """
+        return S.Zero
+
+    def midpoint(self, p):
+        """The midpoint between self and point p.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        midpoint : Point
+
+        See Also
+        ========
+
+        sympy.geometry.line.Segment.midpoint
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+        >>> p1, p2 = Point(1, 1), Point(13, 5)
+        >>> p1.midpoint(p2)
+        Point2D(7, 3)
+
+        """
+        s, p = Point._normalize_dimension(self, Point(p))
+        return Point([simplify((a + b)*S.Half) for a, b in zip(s, p)])
+
+    @property
+    def origin(self):
+        """A point of all zeros of the same ambient dimension
+        as the current point"""
+        return Point([0]*len(self), evaluate=False)
+
+    @property
+    def orthogonal_direction(self):
+        """Returns a non-zero point that is orthogonal to the
+        line containing `self` and the origin.
+
+        Examples
+        ========
+
+        >>> from sympy import Line, Point
+        >>> a = Point(1, 2, 3)
+        >>> a.orthogonal_direction
+        Point3D(-2, 1, 0)
+        >>> b = _
+        >>> Line(b, b.origin).is_perpendicular(Line(a, a.origin))
+        True
+        """
+        dim = self.ambient_dimension
+        # if a coordinate is zero, we can put a 1 there and zeros elsewhere
+        if self[0].is_zero:
+            return Point([1] + (dim - 1)*[0])
+        if self[1].is_zero:
+            return Point([0,1] + (dim - 2)*[0])
+        # if the first two coordinates aren't zero, we can create a non-zero
+        # orthogonal vector by swapping them, negating one, and padding with zeros
+        return Point([-self[1], self[0]] + (dim - 2)*[0])
+
+    @staticmethod
+    def project(a, b):
+        """Project the point `a` onto the line between the origin
+        and point `b` along the normal direction.
+
+        Parameters
+        ==========
+
+        a : Point
+        b : Point
+
+        Returns
+        =======
+
+        p : Point
+
+        See Also
+        ========
+
+        sympy.geometry.line.LinearEntity.projection
+
+        Examples
+        ========
+
+        >>> from sympy import Line, Point
+        >>> a = Point(1, 2)
+        >>> b = Point(2, 5)
+        >>> z = a.origin
+        >>> p = Point.project(a, b)
+        >>> Line(p, a).is_perpendicular(Line(p, b))
+        True
+        >>> Point.is_collinear(z, p, b)
+        True
+        """
+        a, b = Point._normalize_dimension(Point(a), Point(b))
+        if b.is_zero:
+            raise ValueError("Cannot project to the zero vector.")
+        return b*(a.dot(b) / b.dot(b))
+
+    def taxicab_distance(self, p):
+        """The Taxicab Distance from self to point p.
+
+        Returns the sum of the horizontal and vertical distances to point p.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        taxicab_distance : The sum of the horizontal
+        and vertical distances to point p.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.distance
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+        >>> p1, p2 = Point(1, 1), Point(4, 5)
+        >>> p1.taxicab_distance(p2)
+        7
+
+        """
+        s, p = Point._normalize_dimension(self, Point(p))
+        return Add(*(abs(a - b) for a, b in zip(s, p)))
+
+    def canberra_distance(self, p):
+        """The Canberra Distance from self to point p.
+
+        Returns the weighted sum of horizontal and vertical distances to
+        point p.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        canberra_distance : The weighted sum of horizontal and vertical
+        distances to point p. The weight used is the sum of absolute values
+        of the coordinates.
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+        >>> p1, p2 = Point(1, 1), Point(3, 3)
+        >>> p1.canberra_distance(p2)
+        1
+        >>> p1, p2 = Point(0, 0), Point(3, 3)
+        >>> p1.canberra_distance(p2)
+        2
+
+        Raises
+        ======
+
+        ValueError when both vectors are zero.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.distance
+
+        """
+
+        s, p = Point._normalize_dimension(self, Point(p))
+        if self.is_zero and p.is_zero:
+            raise ValueError("Cannot project to the zero vector.")
+        return Add(*((abs(a - b)/(abs(a) + abs(b))) for a, b in zip(s, p)))
+
+    @property
+    def unit(self):
+        """Return the Point that is in the same direction as `self`
+        and a distance of 1 from the origin"""
+        return self / abs(self)
+
+
+class Point2D(Point):
+    """A point in a 2-dimensional Euclidean space.
+
+    Parameters
+    ==========
+
+    coords
+        A sequence of 2 coordinate values.
+
+    Attributes
+    ==========
+
+    x
+    y
+    length
+
+    Raises
+    ======
+
+    TypeError
+        When trying to add or subtract points with different dimensions.
+        When trying to create a point with more than two dimensions.
+        When `intersection` is called with object other than a Point.
+
+    See Also
+    ========
+
+    sympy.geometry.line.Segment : Connects two Points
+
+    Examples
+    ========
+
+    >>> from sympy import Point2D
+    >>> from sympy.abc import x
+    >>> Point2D(1, 2)
+    Point2D(1, 2)
+    >>> Point2D([1, 2])
+    Point2D(1, 2)
+    >>> Point2D(0, x)
+    Point2D(0, x)
+
+    Floats are automatically converted to Rational unless the
+    evaluate flag is False:
+
+    >>> Point2D(0.5, 0.25)
+    Point2D(1/2, 1/4)
+    >>> Point2D(0.5, 0.25, evaluate=False)
+    Point2D(0.5, 0.25)
+
+    """
+
+    _ambient_dimension = 2
+
+    def __new__(cls, *args, _nocheck=False, **kwargs):
+        if not _nocheck:
+            kwargs['dim'] = 2
+            args = Point(*args, **kwargs)
+        return GeometryEntity.__new__(cls, *args)
+
+    def __contains__(self, item):
+        return item == self
+
+    @property
+    def bounds(self):
+        """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+        rectangle for the geometric figure.
+
+        """
+
+        return (self.x, self.y, self.x, self.y)
+
+    def rotate(self, angle, pt=None):
+        """Rotate ``angle`` radians counterclockwise about Point ``pt``.
+
+        See Also
+        ========
+
+        translate, scale
+
+        Examples
+        ========
+
+        >>> from sympy import Point2D, pi
+        >>> t = Point2D(1, 0)
+        >>> t.rotate(pi/2)
+        Point2D(0, 1)
+        >>> t.rotate(pi/2, (2, 0))
+        Point2D(2, -1)
+
+        """
+        c = cos(angle)
+        s = sin(angle)
+
+        rv = self
+        if pt is not None:
+            pt = Point(pt, dim=2)
+            rv -= pt
+        x, y = rv.args
+        rv = Point(c*x - s*y, s*x + c*y)
+        if pt is not None:
+            rv += pt
+        return rv
+
+    def scale(self, x=1, y=1, pt=None):
+        """Scale the coordinates of the Point by multiplying by
+        ``x`` and ``y`` after subtracting ``pt`` -- default is (0, 0) --
+        and then adding ``pt`` back again (i.e. ``pt`` is the point of
+        reference for the scaling).
+
+        See Also
+        ========
+
+        rotate, translate
+
+        Examples
+        ========
+
+        >>> from sympy import Point2D
+        >>> t = Point2D(1, 1)
+        >>> t.scale(2)
+        Point2D(2, 1)
+        >>> t.scale(2, 2)
+        Point2D(2, 2)
+
+        """
+        if pt:
+            pt = Point(pt, dim=2)
+            return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+        return Point(self.x*x, self.y*y)
+
+    def transform(self, matrix):
+        """Return the point after applying the transformation described
+        by the 3x3 Matrix, ``matrix``.
+
+        See Also
+        ========
+        sympy.geometry.point.Point2D.rotate
+        sympy.geometry.point.Point2D.scale
+        sympy.geometry.point.Point2D.translate
+        """
+        if not (matrix.is_Matrix and matrix.shape == (3, 3)):
+            raise ValueError("matrix must be a 3x3 matrix")
+        x, y = self.args
+        return Point(*(Matrix(1, 3, [x, y, 1])*matrix).tolist()[0][:2])
+
+    def translate(self, x=0, y=0):
+        """Shift the Point by adding x and y to the coordinates of the Point.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point2D.rotate, scale
+
+        Examples
+        ========
+
+        >>> from sympy import Point2D
+        >>> t = Point2D(0, 1)
+        >>> t.translate(2)
+        Point2D(2, 1)
+        >>> t.translate(2, 2)
+        Point2D(2, 3)
+        >>> t + Point2D(2, 2)
+        Point2D(2, 3)
+
+        """
+        return Point(self.x + x, self.y + y)
+
+    @property
+    def coordinates(self):
+        """
+        Returns the two coordinates of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point2D
+        >>> p = Point2D(0, 1)
+        >>> p.coordinates
+        (0, 1)
+        """
+        return self.args
+
+    @property
+    def x(self):
+        """
+        Returns the X coordinate of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point2D
+        >>> p = Point2D(0, 1)
+        >>> p.x
+        0
+        """
+        return self.args[0]
+
+    @property
+    def y(self):
+        """
+        Returns the Y coordinate of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point2D
+        >>> p = Point2D(0, 1)
+        >>> p.y
+        1
+        """
+        return self.args[1]
+
+class Point3D(Point):
+    """A point in a 3-dimensional Euclidean space.
+
+    Parameters
+    ==========
+
+    coords
+        A sequence of 3 coordinate values.
+
+    Attributes
+    ==========
+
+    x
+    y
+    z
+    length
+
+    Raises
+    ======
+
+    TypeError
+        When trying to add or subtract points with different dimensions.
+        When `intersection` is called with object other than a Point.
+
+    Examples
+    ========
+
+    >>> from sympy import Point3D
+    >>> from sympy.abc import x
+    >>> Point3D(1, 2, 3)
+    Point3D(1, 2, 3)
+    >>> Point3D([1, 2, 3])
+    Point3D(1, 2, 3)
+    >>> Point3D(0, x, 3)
+    Point3D(0, x, 3)
+
+    Floats are automatically converted to Rational unless the
+    evaluate flag is False:
+
+    >>> Point3D(0.5, 0.25, 2)
+    Point3D(1/2, 1/4, 2)
+    >>> Point3D(0.5, 0.25, 3, evaluate=False)
+    Point3D(0.5, 0.25, 3)
+
+    """
+
+    _ambient_dimension = 3
+
+    def __new__(cls, *args, _nocheck=False, **kwargs):
+        if not _nocheck:
+            kwargs['dim'] = 3
+            args = Point(*args, **kwargs)
+        return GeometryEntity.__new__(cls, *args)
+
+    def __contains__(self, item):
+        return item == self
+
+    @staticmethod
+    def are_collinear(*points):
+        """Is a sequence of points collinear?
+
+        Test whether or not a set of points are collinear. Returns True if
+        the set of points are collinear, or False otherwise.
+
+        Parameters
+        ==========
+
+        points : sequence of Point
+
+        Returns
+        =======
+
+        are_collinear : boolean
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line3D
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> from sympy.abc import x
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(1, 1, 1)
+        >>> p3, p4, p5 = Point3D(2, 2, 2), Point3D(x, x, x), Point3D(1, 2, 6)
+        >>> Point3D.are_collinear(p1, p2, p3, p4)
+        True
+        >>> Point3D.are_collinear(p1, p2, p3, p5)
+        False
+        """
+        return Point.is_collinear(*points)
+
+    def direction_cosine(self, point):
+        """
+        Gives the direction cosine between 2 points
+
+        Parameters
+        ==========
+
+        p : Point3D
+
+        Returns
+        =======
+
+        list
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p1 = Point3D(1, 2, 3)
+        >>> p1.direction_cosine(Point3D(2, 3, 5))
+        [sqrt(6)/6, sqrt(6)/6, sqrt(6)/3]
+        """
+        a = self.direction_ratio(point)
+        b = sqrt(Add(*(i**2 for i in a)))
+        return [(point.x - self.x) / b,(point.y - self.y) / b,
+                (point.z - self.z) / b]
+
+    def direction_ratio(self, point):
+        """
+        Gives the direction ratio between 2 points
+
+        Parameters
+        ==========
+
+        p : Point3D
+
+        Returns
+        =======
+
+        list
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p1 = Point3D(1, 2, 3)
+        >>> p1.direction_ratio(Point3D(2, 3, 5))
+        [1, 1, 2]
+        """
+        return [(point.x - self.x),(point.y - self.y),(point.z - self.z)]
+
+    def intersection(self, other):
+        """The intersection between this point and another GeometryEntity.
+
+        Parameters
+        ==========
+
+        other : GeometryEntity or sequence of coordinates
+
+        Returns
+        =======
+
+        intersection : list of Points
+
+        Notes
+        =====
+
+        The return value will either be an empty list if there is no
+        intersection, otherwise it will contain this point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, 0, 0)
+        >>> p1.intersection(p2)
+        []
+        >>> p1.intersection(p3)
+        [Point3D(0, 0, 0)]
+
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=3)
+        if isinstance(other, Point3D):
+            if self == other:
+                return [self]
+            return []
+        return other.intersection(self)
+
+    def scale(self, x=1, y=1, z=1, pt=None):
+        """Scale the coordinates of the Point by multiplying by
+        ``x`` and ``y`` after subtracting ``pt`` -- default is (0, 0) --
+        and then adding ``pt`` back again (i.e. ``pt`` is the point of
+        reference for the scaling).
+
+        See Also
+        ========
+
+        translate
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> t = Point3D(1, 1, 1)
+        >>> t.scale(2)
+        Point3D(2, 1, 1)
+        >>> t.scale(2, 2)
+        Point3D(2, 2, 1)
+
+        """
+        if pt:
+            pt = Point3D(pt)
+            return self.translate(*(-pt).args).scale(x, y, z).translate(*pt.args)
+        return Point3D(self.x*x, self.y*y, self.z*z)
+
+    def transform(self, matrix):
+        """Return the point after applying the transformation described
+        by the 4x4 Matrix, ``matrix``.
+
+        See Also
+        ========
+        sympy.geometry.point.Point3D.scale
+        sympy.geometry.point.Point3D.translate
+        """
+        if not (matrix.is_Matrix and matrix.shape == (4, 4)):
+            raise ValueError("matrix must be a 4x4 matrix")
+        x, y, z = self.args
+        m = Transpose(matrix)
+        return Point3D(*(Matrix(1, 4, [x, y, z, 1])*m).tolist()[0][:3])
+
+    def translate(self, x=0, y=0, z=0):
+        """Shift the Point by adding x and y to the coordinates of the Point.
+
+        See Also
+        ========
+
+        scale
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> t = Point3D(0, 1, 1)
+        >>> t.translate(2)
+        Point3D(2, 1, 1)
+        >>> t.translate(2, 2)
+        Point3D(2, 3, 1)
+        >>> t + Point3D(2, 2, 2)
+        Point3D(2, 3, 3)
+
+        """
+        return Point3D(self.x + x, self.y + y, self.z + z)
+
+    @property
+    def coordinates(self):
+        """
+        Returns the three coordinates of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p = Point3D(0, 1, 2)
+        >>> p.coordinates
+        (0, 1, 2)
+        """
+        return self.args
+
+    @property
+    def x(self):
+        """
+        Returns the X coordinate of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p = Point3D(0, 1, 3)
+        >>> p.x
+        0
+        """
+        return self.args[0]
+
+    @property
+    def y(self):
+        """
+        Returns the Y coordinate of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p = Point3D(0, 1, 2)
+        >>> p.y
+        1
+        """
+        return self.args[1]
+
+    @property
+    def z(self):
+        """
+        Returns the Z coordinate of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p = Point3D(0, 1, 1)
+        >>> p.z
+        1
+        """
+        return self.args[2]

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

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

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

@@ -0,0 +1,643 @@
+"""Symbolic primitives + unicode/ASCII abstraction for pretty.py"""
+
+import sys
+import warnings
+from string import ascii_lowercase, ascii_uppercase
+import unicodedata
+
+unicode_warnings = ''
+
+def U(name):
+    """
+    Get a unicode character by name or, None if not found.
+
+    This exists because older versions of Python use older unicode databases.
+    """
+    try:
+        return unicodedata.lookup(name)
+    except KeyError:
+        global unicode_warnings
+        unicode_warnings += 'No \'%s\' in unicodedata\n' % name
+        return None
+
+from sympy.printing.conventions import split_super_sub
+from sympy.core.alphabets import greeks
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+# prefix conventions when constructing tables
+# L   - LATIN     i
+# G   - GREEK     beta
+# D   - DIGIT     0
+# S   - SYMBOL    +
+
+
+__all__ = ['greek_unicode', 'sub', 'sup', 'xsym', 'vobj', 'hobj', 'pretty_symbol',
+           'annotated']
+
+
+_use_unicode = False
+
+
+def pretty_use_unicode(flag=None):
+    """Set whether pretty-printer should use unicode by default"""
+    global _use_unicode
+    global unicode_warnings
+    if flag is None:
+        return _use_unicode
+
+    if flag and unicode_warnings:
+        # print warnings (if any) on first unicode usage
+        warnings.warn(unicode_warnings)
+        unicode_warnings = ''
+
+    use_unicode_prev = _use_unicode
+    _use_unicode = flag
+    return use_unicode_prev
+
+
+def pretty_try_use_unicode():
+    """See if unicode output is available and leverage it if possible"""
+
+    encoding = getattr(sys.stdout, 'encoding', None)
+
+    # this happens when e.g. stdout is redirected through a pipe, or is
+    # e.g. a cStringIO.StringO
+    if encoding is None:
+        return  # sys.stdout has no encoding
+
+    symbols = []
+
+    # see if we can represent greek alphabet
+    symbols += greek_unicode.values()
+
+    # and atoms
+    symbols += atoms_table.values()
+
+    for s in symbols:
+        if s is None:
+            return  # common symbols not present!
+
+        try:
+            s.encode(encoding)
+        except UnicodeEncodeError:
+            return
+
+    # all the characters were present and encodable
+    pretty_use_unicode(True)
+
+
+def xstr(*args):
+    sympy_deprecation_warning(
+        """
+        The sympy.printing.pretty.pretty_symbology.xstr() function is
+        deprecated. Use str() instead.
+        """,
+        deprecated_since_version="1.7",
+        active_deprecations_target="deprecated-pretty-printing-functions"
+    )
+    return str(*args)
+
+# GREEK
+g = lambda l: U('GREEK SMALL LETTER %s' % l.upper())
+G = lambda l: U('GREEK CAPITAL LETTER %s' % l.upper())
+
+greek_letters = list(greeks) # make a copy
+# deal with Unicode's funny spelling of lambda
+greek_letters[greek_letters.index('lambda')] = 'lamda'
+
+# {}  greek letter -> (g,G)
+greek_unicode = {L: g(L) for L in greek_letters}
+greek_unicode.update((L[0].upper() + L[1:], G(L)) for L in greek_letters)
+
+# aliases
+greek_unicode['lambda'] = greek_unicode['lamda']
+greek_unicode['Lambda'] = greek_unicode['Lamda']
+greek_unicode['varsigma'] = '\N{GREEK SMALL LETTER FINAL SIGMA}'
+
+# BOLD
+b = lambda l: U('MATHEMATICAL BOLD SMALL %s' % l.upper())
+B = lambda l: U('MATHEMATICAL BOLD CAPITAL %s' % l.upper())
+
+bold_unicode = {l: b(l) for l in ascii_lowercase}
+bold_unicode.update((L, B(L)) for L in ascii_uppercase)
+
+# GREEK BOLD
+gb = lambda l: U('MATHEMATICAL BOLD SMALL %s' % l.upper())
+GB = lambda l: U('MATHEMATICAL BOLD CAPITAL  %s' % l.upper())
+
+greek_bold_letters = list(greeks) # make a copy, not strictly required here
+# deal with Unicode's funny spelling of lambda
+greek_bold_letters[greek_bold_letters.index('lambda')] = 'lamda'
+
+# {}  greek letter -> (g,G)
+greek_bold_unicode = {L: g(L) for L in greek_bold_letters}
+greek_bold_unicode.update((L[0].upper() + L[1:], G(L)) for L in greek_bold_letters)
+greek_bold_unicode['lambda'] = greek_unicode['lamda']
+greek_bold_unicode['Lambda'] = greek_unicode['Lamda']
+greek_bold_unicode['varsigma'] = '\N{MATHEMATICAL BOLD SMALL FINAL SIGMA}'
+
+digit_2txt = {
+    '0':    'ZERO',
+    '1':    'ONE',
+    '2':    'TWO',
+    '3':    'THREE',
+    '4':    'FOUR',
+    '5':    'FIVE',
+    '6':    'SIX',
+    '7':    'SEVEN',
+    '8':    'EIGHT',
+    '9':    'NINE',
+}
+
+symb_2txt = {
+    '+':    'PLUS SIGN',
+    '-':    'MINUS',
+    '=':    'EQUALS SIGN',
+    '(':    'LEFT PARENTHESIS',
+    ')':    'RIGHT PARENTHESIS',
+    '[':    'LEFT SQUARE BRACKET',
+    ']':    'RIGHT SQUARE BRACKET',
+    '{':    'LEFT CURLY BRACKET',
+    '}':    'RIGHT CURLY BRACKET',
+
+    # non-std
+    '{}':   'CURLY BRACKET',
+    'sum':  'SUMMATION',
+    'int':  'INTEGRAL',
+}
+
+# SUBSCRIPT & SUPERSCRIPT
+LSUB = lambda letter: U('LATIN SUBSCRIPT SMALL LETTER %s' % letter.upper())
+GSUB = lambda letter: U('GREEK SUBSCRIPT SMALL LETTER %s' % letter.upper())
+DSUB = lambda digit:  U('SUBSCRIPT %s' % digit_2txt[digit])
+SSUB = lambda symb:   U('SUBSCRIPT %s' % symb_2txt[symb])
+
+LSUP = lambda letter: U('SUPERSCRIPT LATIN SMALL LETTER %s' % letter.upper())
+DSUP = lambda digit:  U('SUPERSCRIPT %s' % digit_2txt[digit])
+SSUP = lambda symb:   U('SUPERSCRIPT %s' % symb_2txt[symb])
+
+sub = {}    # symb -> subscript symbol
+sup = {}    # symb -> superscript symbol
+
+# latin subscripts
+for l in 'aeioruvxhklmnpst':
+    sub[l] = LSUB(l)
+
+for l in 'in':
+    sup[l] = LSUP(l)
+
+for gl in ['beta', 'gamma', 'rho', 'phi', 'chi']:
+    sub[gl] = GSUB(gl)
+
+for d in [str(i) for i in range(10)]:
+    sub[d] = DSUB(d)
+    sup[d] = DSUP(d)
+
+for s in '+-=()':
+    sub[s] = SSUB(s)
+    sup[s] = SSUP(s)
+
+# Variable modifiers
+# TODO: Make brackets adjust to height of contents
+modifier_dict = {
+    # Accents
+    'mathring': lambda s: center_accent(s, '\N{COMBINING RING ABOVE}'),
+    'ddddot': lambda s: center_accent(s, '\N{COMBINING FOUR DOTS ABOVE}'),
+    'dddot': lambda s: center_accent(s, '\N{COMBINING THREE DOTS ABOVE}'),
+    'ddot': lambda s: center_accent(s, '\N{COMBINING DIAERESIS}'),
+    'dot': lambda s: center_accent(s, '\N{COMBINING DOT ABOVE}'),
+    'check': lambda s: center_accent(s, '\N{COMBINING CARON}'),
+    'breve': lambda s: center_accent(s, '\N{COMBINING BREVE}'),
+    'acute': lambda s: center_accent(s, '\N{COMBINING ACUTE ACCENT}'),
+    'grave': lambda s: center_accent(s, '\N{COMBINING GRAVE ACCENT}'),
+    'tilde': lambda s: center_accent(s, '\N{COMBINING TILDE}'),
+    'hat': lambda s: center_accent(s, '\N{COMBINING CIRCUMFLEX ACCENT}'),
+    'bar': lambda s: center_accent(s, '\N{COMBINING OVERLINE}'),
+    'vec': lambda s: center_accent(s, '\N{COMBINING RIGHT ARROW ABOVE}'),
+    'prime': lambda s: s+'\N{PRIME}',
+    'prm': lambda s: s+'\N{PRIME}',
+    # # Faces -- these are here for some compatibility with latex printing
+    # 'bold': lambda s: s,
+    # 'bm': lambda s: s,
+    # 'cal': lambda s: s,
+    # 'scr': lambda s: s,
+    # 'frak': lambda s: s,
+    # Brackets
+    'norm': lambda s: '\N{DOUBLE VERTICAL LINE}'+s+'\N{DOUBLE VERTICAL LINE}',
+    'avg': lambda s: '\N{MATHEMATICAL LEFT ANGLE BRACKET}'+s+'\N{MATHEMATICAL RIGHT ANGLE BRACKET}',
+    'abs': lambda s: '\N{VERTICAL LINE}'+s+'\N{VERTICAL LINE}',
+    'mag': lambda s: '\N{VERTICAL LINE}'+s+'\N{VERTICAL LINE}',
+}
+
+# VERTICAL OBJECTS
+HUP = lambda symb: U('%s UPPER HOOK' % symb_2txt[symb])
+CUP = lambda symb: U('%s UPPER CORNER' % symb_2txt[symb])
+MID = lambda symb: U('%s MIDDLE PIECE' % symb_2txt[symb])
+EXT = lambda symb: U('%s EXTENSION' % symb_2txt[symb])
+HLO = lambda symb: U('%s LOWER HOOK' % symb_2txt[symb])
+CLO = lambda symb: U('%s LOWER CORNER' % symb_2txt[symb])
+TOP = lambda symb: U('%s TOP' % symb_2txt[symb])
+BOT = lambda symb: U('%s BOTTOM' % symb_2txt[symb])
+
+# {} '('  ->  (extension, start, end, middle) 1-character
+_xobj_unicode = {
+
+    # vertical symbols
+    #       (( ext, top, bot, mid ), c1)
+    '(':    (( EXT('('), HUP('('), HLO('(') ), '('),
+    ')':    (( EXT(')'), HUP(')'), HLO(')') ), ')'),
+    '[':    (( EXT('['), CUP('['), CLO('[') ), '['),
+    ']':    (( EXT(']'), CUP(']'), CLO(']') ), ']'),
+    '{':    (( EXT('{}'), HUP('{'), HLO('{'), MID('{') ), '{'),
+    '}':    (( EXT('{}'), HUP('}'), HLO('}'), MID('}') ), '}'),
+    '|':    U('BOX DRAWINGS LIGHT VERTICAL'),
+
+    '<':    ((U('BOX DRAWINGS LIGHT VERTICAL'),
+              U('BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT'),
+              U('BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT')), '<'),
+
+    '>':    ((U('BOX DRAWINGS LIGHT VERTICAL'),
+              U('BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT'),
+              U('BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT')), '>'),
+
+    'lfloor': (( EXT('['), EXT('['), CLO('[') ), U('LEFT FLOOR')),
+    'rfloor': (( EXT(']'), EXT(']'), CLO(']') ), U('RIGHT FLOOR')),
+    'lceil':  (( EXT('['), CUP('['), EXT('[') ), U('LEFT CEILING')),
+    'rceil':  (( EXT(']'), CUP(']'), EXT(']') ), U('RIGHT CEILING')),
+
+    'int':  (( EXT('int'), U('TOP HALF INTEGRAL'), U('BOTTOM HALF INTEGRAL') ), U('INTEGRAL')),
+    'sum':  (( U('BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT'), '_', U('OVERLINE'), U('BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT')), U('N-ARY SUMMATION')),
+
+    # horizontal objects
+    #'-':   '-',
+    '-':    U('BOX DRAWINGS LIGHT HORIZONTAL'),
+    '_':    U('LOW LINE'),
+    # We used to use this, but LOW LINE looks better for roots, as it's a
+    # little lower (i.e., it lines up with the / perfectly.  But perhaps this
+    # one would still be wanted for some cases?
+    # '_':    U('HORIZONTAL SCAN LINE-9'),
+
+    # diagonal objects '\' & '/' ?
+    '/':    U('BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT'),
+    '\\':   U('BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT'),
+}
+
+_xobj_ascii = {
+    # vertical symbols
+    #       (( ext, top, bot, mid ), c1)
+    '(':    (( '|', '/', '\\' ), '('),
+    ')':    (( '|', '\\', '/' ), ')'),
+
+# XXX this looks ugly
+#   '[':    (( '|', '-', '-' ), '['),
+#   ']':    (( '|', '-', '-' ), ']'),
+# XXX not so ugly :(
+    '[':    (( '[', '[', '[' ), '['),
+    ']':    (( ']', ']', ']' ), ']'),
+
+    '{':    (( '|', '/', '\\', '<' ), '{'),
+    '}':    (( '|', '\\', '/', '>' ), '}'),
+    '|':    '|',
+
+    '<':    (( '|', '/', '\\' ), '<'),
+    '>':    (( '|', '\\', '/' ), '>'),
+
+    'int':  ( ' | ', '  /', '/  ' ),
+
+    # horizontal objects
+    '-':    '-',
+    '_':    '_',
+
+    # diagonal objects '\' & '/' ?
+    '/':    '/',
+    '\\':   '\\',
+}
+
+
+def xobj(symb, length):
+    """Construct spatial object of given length.
+
+    return: [] of equal-length strings
+    """
+
+    if length <= 0:
+        raise ValueError("Length should be greater than 0")
+
+    # TODO robustify when no unicodedat available
+    if _use_unicode:
+        _xobj = _xobj_unicode
+    else:
+        _xobj = _xobj_ascii
+
+    vinfo = _xobj[symb]
+
+    c1 = top = bot = mid = None
+
+    if not isinstance(vinfo, tuple):        # 1 entry
+        ext = vinfo
+    else:
+        if isinstance(vinfo[0], tuple):     # (vlong), c1
+            vlong = vinfo[0]
+            c1 = vinfo[1]
+        else:                               # (vlong), c1
+            vlong = vinfo
+
+        ext = vlong[0]
+
+        try:
+            top = vlong[1]
+            bot = vlong[2]
+            mid = vlong[3]
+        except IndexError:
+            pass
+
+    if c1 is None:
+        c1 = ext
+    if top is None:
+        top = ext
+    if bot is None:
+        bot = ext
+    if mid is not None:
+        if (length % 2) == 0:
+            # even height, but we have to print it somehow anyway...
+            # XXX is it ok?
+            length += 1
+
+    else:
+        mid = ext
+
+    if length == 1:
+        return c1
+
+    res = []
+    next = (length - 2)//2
+    nmid = (length - 2) - next*2
+
+    res += [top]
+    res += [ext]*next
+    res += [mid]*nmid
+    res += [ext]*next
+    res += [bot]
+
+    return res
+
+
+def vobj(symb, height):
+    """Construct vertical object of a given height
+
+       see: xobj
+    """
+    return '\n'.join( xobj(symb, height) )
+
+
+def hobj(symb, width):
+    """Construct horizontal object of a given width
+
+       see: xobj
+    """
+    return ''.join( xobj(symb, width) )
+
+# RADICAL
+# n -> symbol
+root = {
+    2: U('SQUARE ROOT'),   # U('RADICAL SYMBOL BOTTOM')
+    3: U('CUBE ROOT'),
+    4: U('FOURTH ROOT'),
+}
+
+
+# RATIONAL
+VF = lambda txt: U('VULGAR FRACTION %s' % txt)
+
+# (p,q) -> symbol
+frac = {
+    (1, 2): VF('ONE HALF'),
+    (1, 3): VF('ONE THIRD'),
+    (2, 3): VF('TWO THIRDS'),
+    (1, 4): VF('ONE QUARTER'),
+    (3, 4): VF('THREE QUARTERS'),
+    (1, 5): VF('ONE FIFTH'),
+    (2, 5): VF('TWO FIFTHS'),
+    (3, 5): VF('THREE FIFTHS'),
+    (4, 5): VF('FOUR FIFTHS'),
+    (1, 6): VF('ONE SIXTH'),
+    (5, 6): VF('FIVE SIXTHS'),
+    (1, 8): VF('ONE EIGHTH'),
+    (3, 8): VF('THREE EIGHTHS'),
+    (5, 8): VF('FIVE EIGHTHS'),
+    (7, 8): VF('SEVEN EIGHTHS'),
+}
+
+
+# atom symbols
+_xsym = {
+    '==':  ('=', '='),
+    '<':   ('<', '<'),
+    '>':   ('>', '>'),
+    '<=':  ('<=', U('LESS-THAN OR EQUAL TO')),
+    '>=':  ('>=', U('GREATER-THAN OR EQUAL TO')),
+    '!=':  ('!=', U('NOT EQUAL TO')),
+    ':=':  (':=', ':='),
+    '+=':  ('+=', '+='),
+    '-=':  ('-=', '-='),
+    '*=':  ('*=', '*='),
+    '/=':  ('/=', '/='),
+    '%=':  ('%=', '%='),
+    '*':   ('*', U('DOT OPERATOR')),
+    '-->': ('-->', U('EM DASH') + U('EM DASH') +
+            U('BLACK RIGHT-POINTING TRIANGLE') if U('EM DASH')
+            and U('BLACK RIGHT-POINTING TRIANGLE') else None),
+    '==>': ('==>', U('BOX DRAWINGS DOUBLE HORIZONTAL') +
+            U('BOX DRAWINGS DOUBLE HORIZONTAL') +
+            U('BLACK RIGHT-POINTING TRIANGLE') if
+            U('BOX DRAWINGS DOUBLE HORIZONTAL') and
+            U('BOX DRAWINGS DOUBLE HORIZONTAL') and
+            U('BLACK RIGHT-POINTING TRIANGLE') else None),
+    '.':   ('*', U('RING OPERATOR')),
+}
+
+
+def xsym(sym):
+    """get symbology for a 'character'"""
+    op = _xsym[sym]
+
+    if _use_unicode:
+        return op[1]
+    else:
+        return op[0]
+
+
+# SYMBOLS
+
+atoms_table = {
+    # class                    how-to-display
+    'Exp1':                    U('SCRIPT SMALL E'),
+    'Pi':                      U('GREEK SMALL LETTER PI'),
+    'Infinity':                U('INFINITY'),
+    'NegativeInfinity':        U('INFINITY') and ('-' + U('INFINITY')),  # XXX what to do here
+    #'ImaginaryUnit':          U('GREEK SMALL LETTER IOTA'),
+    #'ImaginaryUnit':          U('MATHEMATICAL ITALIC SMALL I'),
+    'ImaginaryUnit':           U('DOUBLE-STRUCK ITALIC SMALL I'),
+    'EmptySet':                U('EMPTY SET'),
+    'Naturals':                U('DOUBLE-STRUCK CAPITAL N'),
+    'Naturals0':               (U('DOUBLE-STRUCK CAPITAL N') and
+                                (U('DOUBLE-STRUCK CAPITAL N') +
+                                 U('SUBSCRIPT ZERO'))),
+    'Integers':                U('DOUBLE-STRUCK CAPITAL Z'),
+    'Rationals':               U('DOUBLE-STRUCK CAPITAL Q'),
+    'Reals':                   U('DOUBLE-STRUCK CAPITAL R'),
+    'Complexes':               U('DOUBLE-STRUCK CAPITAL C'),
+    'Union':                   U('UNION'),
+    'SymmetricDifference':     U('INCREMENT'),
+    'Intersection':            U('INTERSECTION'),
+    'Ring':                    U('RING OPERATOR'),
+    'Modifier Letter Low Ring':U('Modifier Letter Low Ring'),
+    'EmptySequence':           'EmptySequence',
+}
+
+
+def pretty_atom(atom_name, default=None, printer=None):
+    """return pretty representation of an atom"""
+    if _use_unicode:
+        if printer is not None and atom_name == 'ImaginaryUnit' and printer._settings['imaginary_unit'] == 'j':
+            return U('DOUBLE-STRUCK ITALIC SMALL J')
+        else:
+            return atoms_table[atom_name]
+    else:
+        if default is not None:
+            return default
+
+        raise KeyError('only unicode')  # send it default printer
+
+
+def pretty_symbol(symb_name, bold_name=False):
+    """return pretty representation of a symbol"""
+    # let's split symb_name into symbol + index
+    # UC: beta1
+    # UC: f_beta
+
+    if not _use_unicode:
+        return symb_name
+
+    name, sups, subs = split_super_sub(symb_name)
+
+    def translate(s, bold_name) :
+        if bold_name:
+            gG = greek_bold_unicode.get(s)
+        else:
+            gG = greek_unicode.get(s)
+        if gG is not None:
+            return gG
+        for key in sorted(modifier_dict.keys(), key=lambda k:len(k), reverse=True) :
+            if s.lower().endswith(key) and len(s)>len(key):
+                return modifier_dict[key](translate(s[:-len(key)], bold_name))
+        if bold_name:
+            return ''.join([bold_unicode[c] for c in s])
+        return s
+
+    name = translate(name, bold_name)
+
+    # Let's prettify sups/subs. If it fails at one of them, pretty sups/subs are
+    # not used at all.
+    def pretty_list(l, mapping):
+        result = []
+        for s in l:
+            pretty = mapping.get(s)
+            if pretty is None:
+                try:  # match by separate characters
+                    pretty = ''.join([mapping[c] for c in s])
+                except (TypeError, KeyError):
+                    return None
+            result.append(pretty)
+        return result
+
+    pretty_sups = pretty_list(sups, sup)
+    if pretty_sups is not None:
+        pretty_subs = pretty_list(subs, sub)
+    else:
+        pretty_subs = None
+
+    # glue the results into one string
+    if pretty_subs is None:  # nice formatting of sups/subs did not work
+        if subs:
+            name += '_'+'_'.join([translate(s, bold_name) for s in subs])
+        if sups:
+            name += '__'+'__'.join([translate(s, bold_name) for s in sups])
+        return name
+    else:
+        sups_result = ' '.join(pretty_sups)
+        subs_result = ' '.join(pretty_subs)
+
+    return ''.join([name, sups_result, subs_result])
+
+
+def annotated(letter):
+    """
+    Return a stylised drawing of the letter ``letter``, together with
+    information on how to put annotations (super- and subscripts to the
+    left and to the right) on it.
+
+    See pretty.py functions _print_meijerg, _print_hyper on how to use this
+    information.
+    """
+    ucode_pics = {
+        'F': (2, 0, 2, 0, '\N{BOX DRAWINGS LIGHT DOWN AND RIGHT}\N{BOX DRAWINGS LIGHT HORIZONTAL}\n'
+                          '\N{BOX DRAWINGS LIGHT VERTICAL AND RIGHT}\N{BOX DRAWINGS LIGHT HORIZONTAL}\n'
+                          '\N{BOX DRAWINGS LIGHT UP}'),
+        'G': (3, 0, 3, 1, '\N{BOX DRAWINGS LIGHT ARC DOWN AND RIGHT}\N{BOX DRAWINGS LIGHT HORIZONTAL}\N{BOX DRAWINGS LIGHT ARC DOWN AND LEFT}\n'
+                          '\N{BOX DRAWINGS LIGHT VERTICAL}\N{BOX DRAWINGS LIGHT RIGHT}\N{BOX DRAWINGS LIGHT DOWN AND LEFT}\n'
+                          '\N{BOX DRAWINGS LIGHT ARC UP AND RIGHT}\N{BOX DRAWINGS LIGHT HORIZONTAL}\N{BOX DRAWINGS LIGHT ARC UP AND LEFT}')
+    }
+    ascii_pics = {
+        'F': (3, 0, 3, 0, ' _\n|_\n|\n'),
+        'G': (3, 0, 3, 1, ' __\n/__\n\\_|')
+    }
+
+    if _use_unicode:
+        return ucode_pics[letter]
+    else:
+        return ascii_pics[letter]
+
+_remove_combining = dict.fromkeys(list(range(ord('\N{COMBINING GRAVE ACCENT}'), ord('\N{COMBINING LATIN SMALL LETTER X}')))
+                            + list(range(ord('\N{COMBINING LEFT HARPOON ABOVE}'), ord('\N{COMBINING ASTERISK ABOVE}'))))
+
+def is_combining(sym):
+    """Check whether symbol is a unicode modifier. """
+
+    return ord(sym) in _remove_combining
+
+
+def center_accent(string, accent):
+    """
+    Returns a string with accent inserted on the middle character. Useful to
+    put combining accents on symbol names, including multi-character names.
+
+    Parameters
+    ==========
+
+    string : string
+        The string to place the accent in.
+    accent : string
+        The combining accent to insert
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Combining_character
+    .. [2] https://en.wikipedia.org/wiki/Combining_Diacritical_Marks
+
+    """
+
+    # Accent is placed on the previous character, although it may not always look
+    # like that depending on console
+    midpoint = len(string) // 2 + 1
+    firstpart = string[:midpoint]
+    secondpart = string[midpoint:]
+    return firstpart + accent + secondpart
+
+
+def line_width(line):
+    """Unicode combining symbols (modifiers) are not ever displayed as
+    separate symbols and thus should not be counted
+    """
+    return len(line.translate(_remove_combining))

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

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

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

@@ -0,0 +1,36 @@
+from .sets import (Set, Interval, Union, FiniteSet, ProductSet,
+        Intersection, imageset, Complement, SymmetricDifference,
+        DisjointUnion)
+
+from .fancysets import ImageSet, Range, ComplexRegion
+from .contains import Contains
+from .conditionset import ConditionSet
+from .ordinals import Ordinal, OmegaPower, ord0
+from .powerset import PowerSet
+from ..core.singleton import S
+from .handlers.comparison import _eval_is_eq  # noqa:F401
+Complexes = S.Complexes
+EmptySet = S.EmptySet
+Integers = S.Integers
+Naturals = S.Naturals
+Naturals0 = S.Naturals0
+Rationals = S.Rationals
+Reals = S.Reals
+UniversalSet = S.UniversalSet
+
+__all__ = [
+    'Set', 'Interval', 'Union', 'EmptySet', 'FiniteSet', 'ProductSet',
+    'Intersection', 'imageset', 'Complement', 'SymmetricDifference', 'DisjointUnion',
+
+    'ImageSet', 'Range', 'ComplexRegion', 'Reals',
+
+    'Contains',
+
+    'ConditionSet',
+
+    'Ordinal', 'OmegaPower', 'ord0',
+
+    'PowerSet',
+
+    'Reals', 'Naturals', 'Naturals0', 'UniversalSet', 'Integers', 'Rationals',
+]

env-llmeval/lib/python3.10/site-packages/sympy/sets/conditionset.py

@@ -0,0 +1,246 @@
+from sympy.core.singleton import S
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.function import Lambda, BadSignatureError
+from sympy.core.logic import fuzzy_bool
+from sympy.core.relational import Eq
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import _sympify
+from sympy.logic.boolalg import And, as_Boolean
+from sympy.utilities.iterables import sift, flatten, has_dups
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from .contains import Contains
+from .sets import Set, Union, FiniteSet, SetKind
+
+
+adummy = Dummy('conditionset')
+
+
+class ConditionSet(Set):
+    r"""
+    Set of elements which satisfies a given condition.
+
+    .. math:: \{x \mid \textrm{condition}(x) = \texttt{True}, x \in S\}
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, S, ConditionSet, pi, Eq, sin, Interval
+    >>> from sympy.abc import x, y, z
+
+    >>> sin_sols = ConditionSet(x, Eq(sin(x), 0), Interval(0, 2*pi))
+    >>> 2*pi in sin_sols
+    True
+    >>> pi/2 in sin_sols
+    False
+    >>> 3*pi in sin_sols
+    False
+    >>> 5 in ConditionSet(x, x**2 > 4, S.Reals)
+    True
+
+    If the value is not in the base set, the result is false:
+
+    >>> 5 in ConditionSet(x, x**2 > 4, Interval(2, 4))
+    False
+
+    Notes
+    =====
+
+    Symbols with assumptions should be avoided or else the
+    condition may evaluate without consideration of the set:
+
+    >>> n = Symbol('n', negative=True)
+    >>> cond = (n > 0); cond
+    False
+    >>> ConditionSet(n, cond, S.Integers)
+    EmptySet
+
+    Only free symbols can be changed by using `subs`:
+
+    >>> c = ConditionSet(x, x < 1, {x, z})
+    >>> c.subs(x, y)
+    ConditionSet(x, x < 1, {y, z})
+
+    To check if ``pi`` is in ``c`` use:
+
+    >>> pi in c
+    False
+
+    If no base set is specified, the universal set is implied:
+
+    >>> ConditionSet(x, x < 1).base_set
+    UniversalSet
+
+    Only symbols or symbol-like expressions can be used:
+
+    >>> ConditionSet(x + 1, x + 1 < 1, S.Integers)
+    Traceback (most recent call last):
+    ...
+    ValueError: non-symbol dummy not recognized in condition
+
+    When the base set is a ConditionSet, the symbols will be
+    unified if possible with preference for the outermost symbols:
+
+    >>> ConditionSet(x, x < y, ConditionSet(z, z + y < 2, S.Integers))
+    ConditionSet(x, (x < y) & (x + y < 2), Integers)
+
+    """
+    def __new__(cls, sym, condition, base_set=S.UniversalSet):
+        sym = _sympify(sym)
+        flat = flatten([sym])
+        if has_dups(flat):
+            raise BadSignatureError("Duplicate symbols detected")
+        base_set = _sympify(base_set)
+        if not isinstance(base_set, Set):
+            raise TypeError(
+                'base set should be a Set object, not %s' % base_set)
+        condition = _sympify(condition)
+
+        if isinstance(condition, FiniteSet):
+            condition_orig = condition
+            temp = (Eq(lhs, 0) for lhs in condition)
+            condition = And(*temp)
+            sympy_deprecation_warning(
+                f"""
+Using a set for the condition in ConditionSet is deprecated. Use a boolean
+instead.
+
+In this case, replace
+
+    {condition_orig}
+
+with
+
+    {condition}
+""",
+                deprecated_since_version='1.5',
+                active_deprecations_target="deprecated-conditionset-set",
+                )
+
+        condition = as_Boolean(condition)
+
+        if condition is S.true:
+            return base_set
+
+        if condition is S.false:
+            return S.EmptySet
+
+        if base_set is S.EmptySet:
+            return S.EmptySet
+
+        # no simple answers, so now check syms
+        for i in flat:
+            if not getattr(i, '_diff_wrt', False):
+                raise ValueError('`%s` is not symbol-like' % i)
+
+        if base_set.contains(sym) is S.false:
+            raise TypeError('sym `%s` is not in base_set `%s`' % (sym, base_set))
+
+        know = None
+        if isinstance(base_set, FiniteSet):
+            sifted = sift(
+                base_set, lambda _: fuzzy_bool(condition.subs(sym, _)))
+            if sifted[None]:
+                know = FiniteSet(*sifted[True])
+                base_set = FiniteSet(*sifted[None])
+            else:
+                return FiniteSet(*sifted[True])
+
+        if isinstance(base_set, cls):
+            s, c, b = base_set.args
+            def sig(s):
+                return cls(s, Eq(adummy, 0)).as_dummy().sym
+            sa, sb = map(sig, (sym, s))
+            if sa != sb:
+                raise BadSignatureError('sym does not match sym of base set')
+            reps = dict(zip(flatten([sym]), flatten([s])))
+            if s == sym:
+                condition = And(condition, c)
+                base_set = b
+            elif not c.free_symbols & sym.free_symbols:
+                reps = {v: k for k, v in reps.items()}
+                condition = And(condition, c.xreplace(reps))
+                base_set = b
+            elif not condition.free_symbols & s.free_symbols:
+                sym = sym.xreplace(reps)
+                condition = And(condition.xreplace(reps), c)
+                base_set = b
+
+        # flatten ConditionSet(Contains(ConditionSet())) expressions
+        if isinstance(condition, Contains) and (sym == condition.args[0]):
+            if isinstance(condition.args[1], Set):
+                return condition.args[1].intersect(base_set)
+
+        rv = Basic.__new__(cls, sym, condition, base_set)
+        return rv if know is None else Union(know, rv)
+
+    sym = property(lambda self: self.args[0])
+    condition = property(lambda self: self.args[1])
+    base_set = property(lambda self: self.args[2])
+
+    @property
+    def free_symbols(self):
+        cond_syms = self.condition.free_symbols - self.sym.free_symbols
+        return cond_syms | self.base_set.free_symbols
+
+    @property
+    def bound_symbols(self):
+        return flatten([self.sym])
+
+    def _contains(self, other):
+        def ok_sig(a, b):
+            tuples = [isinstance(i, Tuple) for i in (a, b)]
+            c = tuples.count(True)
+            if c == 1:
+                return False
+            if c == 0:
+                return True
+            return len(a) == len(b) and all(
+                ok_sig(i, j) for i, j in zip(a, b))
+        if not ok_sig(self.sym, other):
+            return S.false
+
+        # try doing base_cond first and return
+        # False immediately if it is False
+        base_cond = Contains(other, self.base_set)
+        if base_cond is S.false:
+            return S.false
+
+        # Substitute other into condition. This could raise e.g. for
+        # ConditionSet(x, 1/x >= 0, Reals).contains(0)
+        lamda = Lambda((self.sym,), self.condition)
+        try:
+            lambda_cond = lamda(other)
+        except TypeError:
+            return Contains(other, self, evaluate=False)
+        else:
+            return And(base_cond, lambda_cond)
+
+    def as_relational(self, other):
+        f = Lambda(self.sym, self.condition)
+        if isinstance(self.sym, Tuple):
+            f = f(*other)
+        else:
+            f = f(other)
+        return And(f, self.base_set.contains(other))
+
+    def _eval_subs(self, old, new):
+        sym, cond, base = self.args
+        dsym = sym.subs(old, adummy)
+        insym = dsym.has(adummy)
+        # prioritize changing a symbol in the base
+        newbase = base.subs(old, new)
+        if newbase != base:
+            if not insym:
+                cond = cond.subs(old, new)
+            return self.func(sym, cond, newbase)
+        if insym:
+            pass  # no change of bound symbols via subs
+        elif getattr(new, '_diff_wrt', False):
+            cond = cond.subs(old, new)
+        else:
+            pass  # let error about the symbol raise from __new__
+        return self.func(sym, cond, base)
+
+    def _kind(self):
+        return SetKind(self.sym.kind)

env-llmeval/lib/python3.10/site-packages/sympy/sets/contains.py

@@ -0,0 +1,48 @@
+from sympy.core import S
+from sympy.core.relational import Eq, Ne
+from sympy.logic.boolalg import BooleanFunction
+from sympy.utilities.misc import func_name
+from .sets import Set
+
+
+class Contains(BooleanFunction):
+    """
+    Asserts that x is an element of the set S.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, Integer, S, Contains
+    >>> Contains(Integer(2), S.Integers)
+    True
+    >>> Contains(Integer(-2), S.Naturals)
+    False
+    >>> i = Symbol('i', integer=True)
+    >>> Contains(i, S.Naturals)
+    Contains(i, Naturals)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Element_%28mathematics%29
+    """
+    @classmethod
+    def eval(cls, x, s):
+
+        if not isinstance(s, Set):
+            raise TypeError('expecting Set, not %s' % func_name(s))
+
+        ret = s.contains(x)
+        if not isinstance(ret, Contains) and (
+                ret in (S.true, S.false) or isinstance(ret, Set)):
+            return ret
+
+    @property
+    def binary_symbols(self):
+        return set().union(*[i.binary_symbols
+            for i in self.args[1].args
+            if i.is_Boolean or i.is_Symbol or
+            isinstance(i, (Eq, Ne))])
+
+    def as_set(self):
+        return self.args[1]

env-llmeval/lib/python3.10/site-packages/sympy/sets/fancysets.py

@@ -0,0 +1,1521 @@
+from functools import reduce
+from itertools import product
+
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.function import Lambda
+from sympy.core.logic import fuzzy_not, fuzzy_or, fuzzy_and
+from sympy.core.mod import Mod
+from sympy.core.numbers import oo, igcd, Rational
+from sympy.core.relational import Eq, is_eq
+from sympy.core.kind import NumberKind
+from sympy.core.singleton import Singleton, S
+from sympy.core.symbol import Dummy, symbols, Symbol
+from sympy.core.sympify import _sympify, sympify, _sympy_converter
+from sympy.functions.elementary.integers import ceiling, floor
+from sympy.functions.elementary.trigonometric import sin, cos
+from sympy.logic.boolalg import And, Or
+from .sets import Set, Interval, Union, FiniteSet, ProductSet, SetKind
+from sympy.utilities.misc import filldedent
+
+
+class Rationals(Set, metaclass=Singleton):
+    """
+    Represents the rational numbers. This set is also available as
+    the singleton ``S.Rationals``.
+
+    Examples
+    ========
+
+    >>> from sympy import S
+    >>> S.Half in S.Rationals
+    True
+    >>> iterable = iter(S.Rationals)
+    >>> [next(iterable) for i in range(12)]
+    [0, 1, -1, 1/2, 2, -1/2, -2, 1/3, 3, -1/3, -3, 2/3]
+    """
+
+    is_iterable = True
+    _inf = S.NegativeInfinity
+    _sup = S.Infinity
+    is_empty = False
+    is_finite_set = False
+
+    def _contains(self, other):
+        if not isinstance(other, Expr):
+            return False
+        return other.is_rational
+
+    def __iter__(self):
+        yield S.Zero
+        yield S.One
+        yield S.NegativeOne
+        d = 2
+        while True:
+            for n in range(d):
+                if igcd(n, d) == 1:
+                    yield Rational(n, d)
+                    yield Rational(d, n)
+                    yield Rational(-n, d)
+                    yield Rational(-d, n)
+            d += 1
+
+    @property
+    def _boundary(self):
+        return S.Reals
+
+    def _kind(self):
+        return SetKind(NumberKind)
+
+
+class Naturals(Set, metaclass=Singleton):
+    """
+    Represents the natural numbers (or counting numbers) which are all
+    positive integers starting from 1. This set is also available as
+    the singleton ``S.Naturals``.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Interval, pprint
+    >>> 5 in S.Naturals
+    True
+    >>> iterable = iter(S.Naturals)
+    >>> next(iterable)
+    1
+    >>> next(iterable)
+    2
+    >>> next(iterable)
+    3
+    >>> pprint(S.Naturals.intersect(Interval(0, 10)))
+    {1, 2, ..., 10}
+
+    See Also
+    ========
+
+    Naturals0 : non-negative integers (i.e. includes 0, too)
+    Integers : also includes negative integers
+    """
+
+    is_iterable = True
+    _inf = S.One
+    _sup = S.Infinity
+    is_empty = False
+    is_finite_set = False
+
+    def _contains(self, other):
+        if not isinstance(other, Expr):
+            return False
+        elif other.is_positive and other.is_integer:
+            return True
+        elif other.is_integer is False or other.is_positive is False:
+            return False
+
+    def _eval_is_subset(self, other):
+        return Range(1, oo).is_subset(other)
+
+    def _eval_is_superset(self, other):
+        return Range(1, oo).is_superset(other)
+
+    def __iter__(self):
+        i = self._inf
+        while True:
+            yield i
+            i = i + 1
+
+    @property
+    def _boundary(self):
+        return self
+
+    def as_relational(self, x):
+        return And(Eq(floor(x), x), x >= self.inf, x < oo)
+
+    def _kind(self):
+        return SetKind(NumberKind)
+
+
+class Naturals0(Naturals):
+    """Represents the whole numbers which are all the non-negative integers,
+    inclusive of zero.
+
+    See Also
+    ========
+
+    Naturals : positive integers; does not include 0
+    Integers : also includes the negative integers
+    """
+    _inf = S.Zero
+
+    def _contains(self, other):
+        if not isinstance(other, Expr):
+            return S.false
+        elif other.is_integer and other.is_nonnegative:
+            return S.true
+        elif other.is_integer is False or other.is_nonnegative is False:
+            return S.false
+
+    def _eval_is_subset(self, other):
+        return Range(oo).is_subset(other)
+
+    def _eval_is_superset(self, other):
+        return Range(oo).is_superset(other)
+
+
+class Integers(Set, metaclass=Singleton):
+    """
+    Represents all integers: positive, negative and zero. This set is also
+    available as the singleton ``S.Integers``.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Interval, pprint
+    >>> 5 in S.Naturals
+    True
+    >>> iterable = iter(S.Integers)
+    >>> next(iterable)
+    0
+    >>> next(iterable)
+    1
+    >>> next(iterable)
+    -1
+    >>> next(iterable)
+    2
+
+    >>> pprint(S.Integers.intersect(Interval(-4, 4)))
+    {-4, -3, ..., 4}
+
+    See Also
+    ========
+
+    Naturals0 : non-negative integers
+    Integers : positive and negative integers and zero
+    """
+
+    is_iterable = True
+    is_empty = False
+    is_finite_set = False
+
+    def _contains(self, other):
+        if not isinstance(other, Expr):
+            return S.false
+        return other.is_integer
+
+    def __iter__(self):
+        yield S.Zero
+        i = S.One
+        while True:
+            yield i
+            yield -i
+            i = i + 1
+
+    @property
+    def _inf(self):
+        return S.NegativeInfinity
+
+    @property
+    def _sup(self):
+        return S.Infinity
+
+    @property
+    def _boundary(self):
+        return self
+
+    def _kind(self):
+        return SetKind(NumberKind)
+
+    def as_relational(self, x):
+        return And(Eq(floor(x), x), -oo < x, x < oo)
+
+    def _eval_is_subset(self, other):
+        return Range(-oo, oo).is_subset(other)
+
+    def _eval_is_superset(self, other):
+        return Range(-oo, oo).is_superset(other)
+
+
+class Reals(Interval, metaclass=Singleton):
+    """
+    Represents all real numbers
+    from negative infinity to positive infinity,
+    including all integer, rational and irrational numbers.
+    This set is also available as the singleton ``S.Reals``.
+
+
+    Examples
+    ========
+
+    >>> from sympy import S, Rational, pi, I
+    >>> 5 in S.Reals
+    True
+    >>> Rational(-1, 2) in S.Reals
+    True
+    >>> pi in S.Reals
+    True
+    >>> 3*I in S.Reals
+    False
+    >>> S.Reals.contains(pi)
+    True
+
+
+    See Also
+    ========
+
+    ComplexRegion
+    """
+    @property
+    def start(self):
+        return S.NegativeInfinity
+
+    @property
+    def end(self):
+        return S.Infinity
+
+    @property
+    def left_open(self):
+        return True
+
+    @property
+    def right_open(self):
+        return True
+
+    def __eq__(self, other):
+        return other == Interval(S.NegativeInfinity, S.Infinity)
+
+    def __hash__(self):
+        return hash(Interval(S.NegativeInfinity, S.Infinity))
+
+
+class ImageSet(Set):
+    """
+    Image of a set under a mathematical function. The transformation
+    must be given as a Lambda function which has as many arguments
+    as the elements of the set upon which it operates, e.g. 1 argument
+    when acting on the set of integers or 2 arguments when acting on
+    a complex region.
+
+    This function is not normally called directly, but is called
+    from ``imageset``.
+
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, S, pi, Dummy, Lambda
+    >>> from sympy import FiniteSet, ImageSet, Interval
+
+    >>> x = Symbol('x')
+    >>> N = S.Naturals
+    >>> squares = ImageSet(Lambda(x, x**2), N) # {x**2 for x in N}
+    >>> 4 in squares
+    True
+    >>> 5 in squares
+    False
+
+    >>> FiniteSet(0, 1, 2, 3, 4, 5, 6, 7, 9, 10).intersect(squares)
+    {1, 4, 9}
+
+    >>> square_iterable = iter(squares)
+    >>> for i in range(4):
+    ...     next(square_iterable)
+    1
+    4
+    9
+    16
+
+    If you want to get value for `x` = 2, 1/2 etc. (Please check whether the
+    `x` value is in ``base_set`` or not before passing it as args)
+
+    >>> squares.lamda(2)
+    4
+    >>> squares.lamda(S(1)/2)
+    1/4
+
+    >>> n = Dummy('n')
+    >>> solutions = ImageSet(Lambda(n, n*pi), S.Integers) # solutions of sin(x) = 0
+    >>> dom = Interval(-1, 1)
+    >>> dom.intersect(solutions)
+    {0}
+
+    See Also
+    ========
+
+    sympy.sets.sets.imageset
+    """
+    def __new__(cls, flambda, *sets):
+        if not isinstance(flambda, Lambda):
+            raise ValueError('First argument must be a Lambda')
+
+        signature = flambda.signature
+
+        if len(signature) != len(sets):
+            raise ValueError('Incompatible signature')
+
+        sets = [_sympify(s) for s in sets]
+
+        if not all(isinstance(s, Set) for s in sets):
+            raise TypeError("Set arguments to ImageSet should of type Set")
+
+        if not all(cls._check_sig(sg, st) for sg, st in zip(signature, sets)):
+            raise ValueError("Signature %s does not match sets %s" % (signature, sets))
+
+        if flambda is S.IdentityFunction and len(sets) == 1:
+            return sets[0]
+
+        if not set(flambda.variables) & flambda.expr.free_symbols:
+            is_empty = fuzzy_or(s.is_empty for s in sets)
+            if is_empty == True:
+                return S.EmptySet
+            elif is_empty == False:
+                return FiniteSet(flambda.expr)
+
+        return Basic.__new__(cls, flambda, *sets)
+
+    lamda = property(lambda self: self.args[0])
+    base_sets = property(lambda self: self.args[1:])
+
+    @property
+    def base_set(self):
+        # XXX: Maybe deprecate this? It is poorly defined in handling
+        # the multivariate case...
+        sets = self.base_sets
+        if len(sets) == 1:
+            return sets[0]
+        else:
+            return ProductSet(*sets).flatten()
+
+    @property
+    def base_pset(self):
+        return ProductSet(*self.base_sets)
+
+    @classmethod
+    def _check_sig(cls, sig_i, set_i):
+        if sig_i.is_symbol:
+            return True
+        elif isinstance(set_i, ProductSet):
+            sets = set_i.sets
+            if len(sig_i) != len(sets):
+                return False
+            # Recurse through the signature for nested tuples:
+            return all(cls._check_sig(ts, ps) for ts, ps in zip(sig_i, sets))
+        else:
+            # XXX: Need a better way of checking whether a set is a set of
+            # Tuples or not. For example a FiniteSet can contain Tuples
+            # but so can an ImageSet or a ConditionSet. Others like
+            # Integers, Reals etc can not contain Tuples. We could just
+            # list the possibilities here... Current code for e.g.
+            # _contains probably only works for ProductSet.
+            return True # Give the benefit of the doubt
+
+    def __iter__(self):
+        already_seen = set()
+        for i in self.base_pset:
+            val = self.lamda(*i)
+            if val in already_seen:
+                continue
+            else:
+                already_seen.add(val)
+                yield val
+
+    def _is_multivariate(self):
+        return len(self.lamda.variables) > 1
+
+    def _contains(self, other):
+        from sympy.solvers.solveset import _solveset_multi
+
+        def get_symsetmap(signature, base_sets):
+            '''Attempt to get a map of symbols to base_sets'''
+            queue = list(zip(signature, base_sets))
+            symsetmap = {}
+            for sig, base_set in queue:
+                if sig.is_symbol:
+                    symsetmap[sig] = base_set
+                elif base_set.is_ProductSet:
+                    sets = base_set.sets
+                    if len(sig) != len(sets):
+                        raise ValueError("Incompatible signature")
+                    # Recurse
+                    queue.extend(zip(sig, sets))
+                else:
+                    # If we get here then we have something like sig = (x, y) and
+                    # base_set = {(1, 2), (3, 4)}. For now we give up.
+                    return None
+
+            return symsetmap
+
+        def get_equations(expr, candidate):
+            '''Find the equations relating symbols in expr and candidate.'''
+            queue = [(expr, candidate)]
+            for e, c in queue:
+                if not isinstance(e, Tuple):
+                    yield Eq(e, c)
+                elif not isinstance(c, Tuple) or len(e) != len(c):
+                    yield False
+                    return
+                else:
+                    queue.extend(zip(e, c))
+
+        # Get the basic objects together:
+        other = _sympify(other)
+        expr = self.lamda.expr
+        sig = self.lamda.signature
+        variables = self.lamda.variables
+        base_sets = self.base_sets
+
+        # Use dummy symbols for ImageSet parameters so they don't match
+        # anything in other
+        rep = {v: Dummy(v.name) for v in variables}
+        variables = [v.subs(rep) for v in variables]
+        sig = sig.subs(rep)
+        expr = expr.subs(rep)
+
+        # Map the parts of other to those in the Lambda expr
+        equations = []
+        for eq in get_equations(expr, other):
+            # Unsatisfiable equation?
+            if eq is False:
+                return False
+            equations.append(eq)
+
+        # Map the symbols in the signature to the corresponding domains
+        symsetmap = get_symsetmap(sig, base_sets)
+        if symsetmap is None:
+            # Can't factor the base sets to a ProductSet
+            return None
+
+        # Which of the variables in the Lambda signature need to be solved for?
+        symss = (eq.free_symbols for eq in equations)
+        variables = set(variables) & reduce(set.union, symss, set())
+
+        # Use internal multivariate solveset
+        variables = tuple(variables)
+        base_sets = [symsetmap[v] for v in variables]
+        solnset = _solveset_multi(equations, variables, base_sets)
+        if solnset is None:
+            return None
+        return fuzzy_not(solnset.is_empty)
+
+    @property
+    def is_iterable(self):
+        return all(s.is_iterable for s in self.base_sets)
+
+    def doit(self, **hints):
+        from sympy.sets.setexpr import SetExpr
+        f = self.lamda
+        sig = f.signature
+        if len(sig) == 1 and sig[0].is_symbol and isinstance(f.expr, Expr):
+            base_set = self.base_sets[0]
+            return SetExpr(base_set)._eval_func(f).set
+        if all(s.is_FiniteSet for s in self.base_sets):
+            return FiniteSet(*(f(*a) for a in product(*self.base_sets)))
+        return self
+
+    def _kind(self):
+        return SetKind(self.lamda.expr.kind)
+
+
+class Range(Set):
+    """
+    Represents a range of integers. Can be called as ``Range(stop)``,
+    ``Range(start, stop)``, or ``Range(start, stop, step)``; when ``step`` is
+    not given it defaults to 1.
+
+    ``Range(stop)`` is the same as ``Range(0, stop, 1)`` and the stop value
+    (just as for Python ranges) is not included in the Range values.
+
+        >>> from sympy import Range
+        >>> list(Range(3))
+        [0, 1, 2]
+
+    The step can also be negative:
+
+        >>> list(Range(10, 0, -2))
+        [10, 8, 6, 4, 2]
+
+    The stop value is made canonical so equivalent ranges always
+    have the same args:
+
+        >>> Range(0, 10, 3)
+        Range(0, 12, 3)
+
+    Infinite ranges are allowed. ``oo`` and ``-oo`` are never included in the
+    set (``Range`` is always a subset of ``Integers``). If the starting point
+    is infinite, then the final value is ``stop - step``. To iterate such a
+    range, it needs to be reversed:
+
+        >>> from sympy import oo
+        >>> r = Range(-oo, 1)
+        >>> r[-1]
+        0
+        >>> next(iter(r))
+        Traceback (most recent call last):
+        ...
+        TypeError: Cannot iterate over Range with infinite start
+        >>> next(iter(r.reversed))
+        0
+
+    Although ``Range`` is a :class:`Set` (and supports the normal set
+    operations) it maintains the order of the elements and can
+    be used in contexts where ``range`` would be used.
+
+        >>> from sympy import Interval
+        >>> Range(0, 10, 2).intersect(Interval(3, 7))
+        Range(4, 8, 2)
+        >>> list(_)
+        [4, 6]
+
+    Although slicing of a Range will always return a Range -- possibly
+    empty -- an empty set will be returned from any intersection that
+    is empty:
+
+        >>> Range(3)[:0]
+        Range(0, 0, 1)
+        >>> Range(3).intersect(Interval(4, oo))
+        EmptySet
+        >>> Range(3).intersect(Range(4, oo))
+        EmptySet
+
+    Range will accept symbolic arguments but has very limited support
+    for doing anything other than displaying the Range:
+
+        >>> from sympy import Symbol, pprint
+        >>> from sympy.abc import i, j, k
+        >>> Range(i, j, k).start
+        i
+        >>> Range(i, j, k).inf
+        Traceback (most recent call last):
+        ...
+        ValueError: invalid method for symbolic range
+
+    Better success will be had when using integer symbols:
+
+        >>> n = Symbol('n', integer=True)
+        >>> r = Range(n, n + 20, 3)
+        >>> r.inf
+        n
+        >>> pprint(r)
+        {n, n + 3, ..., n + 18}
+    """
+
+    def __new__(cls, *args):
+        if len(args) == 1:
+            if isinstance(args[0], range):
+                raise TypeError(
+                    'use sympify(%s) to convert range to Range' % args[0])
+
+        # expand range
+        slc = slice(*args)
+
+        if slc.step == 0:
+            raise ValueError("step cannot be 0")
+
+        start, stop, step = slc.start or 0, slc.stop, slc.step or 1
+        try:
+            ok = []
+            for w in (start, stop, step):
+                w = sympify(w)
+                if w in [S.NegativeInfinity, S.Infinity] or (
+                        w.has(Symbol) and w.is_integer != False):
+                    ok.append(w)
+                elif not w.is_Integer:
+                    if w.is_infinite:
+                        raise ValueError('infinite symbols not allowed')
+                    raise ValueError
+                else:
+                    ok.append(w)
+        except ValueError:
+            raise ValueError(filldedent('''
+    Finite arguments to Range must be integers; `imageset` can define
+    other cases, e.g. use `imageset(i, i/10, Range(3))` to give
+    [0, 1/10, 1/5].'''))
+        start, stop, step = ok
+
+        null = False
+        if any(i.has(Symbol) for i in (start, stop, step)):
+            dif = stop - start
+            n = dif/step
+            if n.is_Rational:
+                if dif == 0:
+                    null = True
+                else:  # (x, x + 5, 2) or (x, 3*x, x)
+                    n = floor(n)
+                    end = start + n*step
+                    if dif.is_Rational:  # (x, x + 5, 2)
+                        if (end - stop).is_negative:
+                            end += step
+                    else:  # (x, 3*x, x)
+                        if (end/stop - 1).is_negative:
+                            end += step
+            elif n.is_extended_negative:
+                null = True
+            else:
+                end = stop  # other methods like sup and reversed must fail
+        elif start.is_infinite:
+            span = step*(stop - start)
+            if span is S.NaN or span <= 0:
+                null = True
+            elif step.is_Integer and stop.is_infinite and abs(step) != 1:
+                raise ValueError(filldedent('''
+                    Step size must be %s in this case.''' % (1 if step > 0 else -1)))
+            else:
+                end = stop
+        else:
+            oostep = step.is_infinite
+            if oostep:
+                step = S.One if step > 0 else S.NegativeOne
+            n = ceiling((stop - start)/step)
+            if n <= 0:
+                null = True
+            elif oostep:
+                step = S.One  # make it canonical
+                end = start + step
+            else:
+                end = start + n*step
+        if null:
+            start = end = S.Zero
+            step = S.One
+        return Basic.__new__(cls, start, end, step)
+
+    start = property(lambda self: self.args[0])
+    stop = property(lambda self: self.args[1])
+    step = property(lambda self: self.args[2])
+
+    @property
+    def reversed(self):
+        """Return an equivalent Range in the opposite order.
+
+        Examples
+        ========
+
+        >>> from sympy import Range
+        >>> Range(10).reversed
+        Range(9, -1, -1)
+        """
+        if self.has(Symbol):
+            n = (self.stop - self.start)/self.step
+            if not n.is_extended_positive or not all(
+                    i.is_integer or i.is_infinite for i in self.args):
+                raise ValueError('invalid method for symbolic range')
+        if self.start == self.stop:
+            return self
+        return self.func(
+            self.stop - self.step, self.start - self.step, -self.step)
+
+    def _kind(self):
+        return SetKind(NumberKind)
+
+    def _contains(self, other):
+        if self.start == self.stop:
+            return S.false
+        if other.is_infinite:
+            return S.false
+        if not other.is_integer:
+            return other.is_integer
+        if self.has(Symbol):
+            n = (self.stop - self.start)/self.step
+            if not n.is_extended_positive or not all(
+                    i.is_integer or i.is_infinite for i in self.args):
+                return
+        else:
+            n = self.size
+        if self.start.is_finite:
+            ref = self.start
+        elif self.stop.is_finite:
+            ref = self.stop
+        else:  # both infinite; step is +/- 1 (enforced by __new__)
+            return S.true
+        if n == 1:
+            return Eq(other, self[0])
+        res = (ref - other) % self.step
+        if res == S.Zero:
+            if self.has(Symbol):
+                d = Dummy('i')
+                return self.as_relational(d).subs(d, other)
+            return And(other >= self.inf, other <= self.sup)
+        elif res.is_Integer:  # off sequence
+            return S.false
+        else:  # symbolic/unsimplified residue modulo step
+            return None
+
+    def __iter__(self):
+        n = self.size  # validate
+        if not (n.has(S.Infinity) or n.has(S.NegativeInfinity) or n.is_Integer):
+            raise TypeError("Cannot iterate over symbolic Range")
+        if self.start in [S.NegativeInfinity, S.Infinity]:
+            raise TypeError("Cannot iterate over Range with infinite start")
+        elif self.start != self.stop:
+            i = self.start
+            if n.is_infinite:
+                while True:
+                    yield i
+                    i += self.step
+            else:
+                for _ in range(n):
+                    yield i
+                    i += self.step
+
+    @property
+    def is_iterable(self):
+        # Check that size can be determined, used by __iter__
+        dif = self.stop - self.start
+        n = dif/self.step
+        if not (n.has(S.Infinity) or n.has(S.NegativeInfinity) or n.is_Integer):
+            return False
+        if self.start in [S.NegativeInfinity, S.Infinity]:
+            return False
+        if not (n.is_extended_nonnegative and all(i.is_integer for i in self.args)):
+            return False
+        return True
+
+    def __len__(self):
+        rv = self.size
+        if rv is S.Infinity:
+            raise ValueError('Use .size to get the length of an infinite Range')
+        return int(rv)
+
+    @property
+    def size(self):
+        if self.start == self.stop:
+            return S.Zero
+        dif = self.stop - self.start
+        n = dif/self.step
+        if n.is_infinite:
+            return S.Infinity
+        if  n.is_extended_nonnegative and all(i.is_integer for i in self.args):
+            return abs(floor(n))
+        raise ValueError('Invalid method for symbolic Range')
+
+    @property
+    def is_finite_set(self):
+        if self.start.is_integer and self.stop.is_integer:
+            return True
+        return self.size.is_finite
+
+    @property
+    def is_empty(self):
+        try:
+            return self.size.is_zero
+        except ValueError:
+            return None
+
+    def __bool__(self):
+        # this only distinguishes between definite null range
+        # and non-null/unknown null; getting True doesn't mean
+        # that it actually is not null
+        b = is_eq(self.start, self.stop)
+        if b is None:
+            raise ValueError('cannot tell if Range is null or not')
+        return not bool(b)
+
+    def __getitem__(self, i):
+        ooslice = "cannot slice from the end with an infinite value"
+        zerostep = "slice step cannot be zero"
+        infinite = "slicing not possible on range with infinite start"
+        # if we had to take every other element in the following
+        # oo, ..., 6, 4, 2, 0
+        # we might get oo, ..., 4, 0 or oo, ..., 6, 2
+        ambiguous = "cannot unambiguously re-stride from the end " + \
+            "with an infinite value"
+        if isinstance(i, slice):
+            if self.size.is_finite:  # validates, too
+                if self.start == self.stop:
+                    return Range(0)
+                start, stop, step = i.indices(self.size)
+                n = ceiling((stop - start)/step)
+                if n <= 0:
+                    return Range(0)
+                canonical_stop = start + n*step
+                end = canonical_stop - step
+                ss = step*self.step
+                return Range(self[start], self[end] + ss, ss)
+            else:  # infinite Range
+                start = i.start
+                stop = i.stop
+                if i.step == 0:
+                    raise ValueError(zerostep)
+                step = i.step or 1
+                ss = step*self.step
+                #---------------------
+                # handle infinite Range
+                #   i.e. Range(-oo, oo) or Range(oo, -oo, -1)
+                # --------------------
+                if self.start.is_infinite and self.stop.is_infinite:
+                    raise ValueError(infinite)
+                #---------------------
+                # handle infinite on right
+                #   e.g. Range(0, oo) or Range(0, -oo, -1)
+                # --------------------
+                if self.stop.is_infinite:
+                    # start and stop are not interdependent --
+                    # they only depend on step --so we use the
+                    # equivalent reversed values
+                    return self.reversed[
+                        stop if stop is None else -stop + 1:
+                        start if start is None else -start:
+                        step].reversed
+                #---------------------
+                # handle infinite on the left
+                #   e.g. Range(oo, 0, -1) or Range(-oo, 0)
+                # --------------------
+                # consider combinations of
+                # start/stop {== None, < 0, == 0, > 0} and
+                # step {< 0, > 0}
+                if start is None:
+                    if stop is None:
+                        if step < 0:
+                            return Range(self[-1], self.start, ss)
+                        elif step > 1:
+                            raise ValueError(ambiguous)
+                        else:  # == 1
+                            return self
+                    elif stop < 0:
+                        if step < 0:
+                            return Range(self[-1], self[stop], ss)
+                        else:  # > 0
+                            return Range(self.start, self[stop], ss)
+                    elif stop == 0:
+                        if step > 0:
+                            return Range(0)
+                        else:  # < 0
+                            raise ValueError(ooslice)
+                    elif stop == 1:
+                        if step > 0:
+                            raise ValueError(ooslice)  # infinite singleton
+                        else:  # < 0
+                            raise ValueError(ooslice)
+                    else:  # > 1
+                        raise ValueError(ooslice)
+                elif start < 0:
+                    if stop is None:
+                        if step < 0:
+                            return Range(self[start], self.start, ss)
+                        else:  # > 0
+                            return Range(self[start], self.stop, ss)
+                    elif stop < 0:
+                        return Range(self[start], self[stop], ss)
+                    elif stop == 0:
+                        if step < 0:
+                            raise ValueError(ooslice)
+                        else:  # > 0
+                            return Range(0)
+                    elif stop > 0:
+                        raise ValueError(ooslice)
+                elif start == 0:
+                    if stop is None:
+                        if step < 0:
+                            raise ValueError(ooslice)  # infinite singleton
+                        elif step > 1:
+                            raise ValueError(ambiguous)
+                        else:  # == 1
+                            return self
+                    elif stop < 0:
+                        if step > 1:
+                            raise ValueError(ambiguous)
+                        elif step == 1:
+                            return Range(self.start, self[stop], ss)
+                        else:  # < 0
+                            return Range(0)
+                    else:  # >= 0
+                        raise ValueError(ooslice)
+                elif start > 0:
+                    raise ValueError(ooslice)
+        else:
+            if self.start == self.stop:
+                raise IndexError('Range index out of range')
+            if not (all(i.is_integer or i.is_infinite
+                    for i in self.args) and ((self.stop - self.start)/
+                    self.step).is_extended_positive):
+                raise ValueError('Invalid method for symbolic Range')
+            if i == 0:
+                if self.start.is_infinite:
+                    raise ValueError(ooslice)
+                return self.start
+            if i == -1:
+                if self.stop.is_infinite:
+                    raise ValueError(ooslice)
+                return self.stop - self.step
+            n = self.size  # must be known for any other index
+            rv = (self.stop if i < 0 else self.start) + i*self.step
+            if rv.is_infinite:
+                raise ValueError(ooslice)
+            val = (rv - self.start)/self.step
+            rel = fuzzy_or([val.is_infinite,
+                            fuzzy_and([val.is_nonnegative, (n-val).is_nonnegative])])
+            if rel:
+                return rv
+            if rel is None:
+                raise ValueError('Invalid method for symbolic Range')
+            raise IndexError("Range index out of range")
+
+    @property
+    def _inf(self):
+        if not self:
+            return S.EmptySet.inf
+        if self.has(Symbol):
+            if all(i.is_integer or i.is_infinite for i in self.args):
+                dif = self.stop - self.start
+                if self.step.is_positive and dif.is_positive:
+                    return self.start
+                elif self.step.is_negative and dif.is_negative:
+                    return self.stop - self.step
+            raise ValueError('invalid method for symbolic range')
+        if self.step > 0:
+            return self.start
+        else:
+            return self.stop - self.step
+
+    @property
+    def _sup(self):
+        if not self:
+            return S.EmptySet.sup
+        if self.has(Symbol):
+            if all(i.is_integer or i.is_infinite for i in self.args):
+                dif = self.stop - self.start
+                if self.step.is_positive and dif.is_positive:
+                    return self.stop - self.step
+                elif self.step.is_negative and dif.is_negative:
+                    return self.start
+            raise ValueError('invalid method for symbolic range')
+        if self.step > 0:
+            return self.stop - self.step
+        else:
+            return self.start
+
+    @property
+    def _boundary(self):
+        return self
+
+    def as_relational(self, x):
+        """Rewrite a Range in terms of equalities and logic operators. """
+        if self.start.is_infinite:
+            assert not self.stop.is_infinite  # by instantiation
+            a = self.reversed.start
+        else:
+            a = self.start
+        step = self.step
+        in_seq = Eq(Mod(x - a, step), 0)
+        ints = And(Eq(Mod(a, 1), 0), Eq(Mod(step, 1), 0))
+        n = (self.stop - self.start)/self.step
+        if n == 0:
+            return S.EmptySet.as_relational(x)
+        if n == 1:
+            return And(Eq(x, a), ints)
+        try:
+            a, b = self.inf, self.sup
+        except ValueError:
+            a = None
+        if a is not None:
+            range_cond = And(
+                x > a if a.is_infinite else x >= a,
+                x < b if b.is_infinite else x <= b)
+        else:
+            a, b = self.start, self.stop - self.step
+            range_cond = Or(
+                And(self.step >= 1, x > a if a.is_infinite else x >= a,
+                x < b if b.is_infinite else x <= b),
+                And(self.step <= -1, x < a if a.is_infinite else x <= a,
+                x > b if b.is_infinite else x >= b))
+        return And(in_seq, ints, range_cond)
+
+
+_sympy_converter[range] = lambda r: Range(r.start, r.stop, r.step)
+
+def normalize_theta_set(theta):
+    r"""
+    Normalize a Real Set `theta` in the interval `[0, 2\pi)`. It returns
+    a normalized value of theta in the Set. For Interval, a maximum of
+    one cycle $[0, 2\pi]$, is returned i.e. for theta equal to $[0, 10\pi]$,
+    returned normalized value would be $[0, 2\pi)$. As of now intervals
+    with end points as non-multiples of ``pi`` is not supported.
+
+    Raises
+    ======
+
+    NotImplementedError
+        The algorithms for Normalizing theta Set are not yet
+        implemented.
+    ValueError
+        The input is not valid, i.e. the input is not a real set.
+    RuntimeError
+        It is a bug, please report to the github issue tracker.
+
+    Examples
+    ========
+
+    >>> from sympy.sets.fancysets import normalize_theta_set
+    >>> from sympy import Interval, FiniteSet, pi
+    >>> normalize_theta_set(Interval(9*pi/2, 5*pi))
+    Interval(pi/2, pi)
+    >>> normalize_theta_set(Interval(-3*pi/2, pi/2))
+    Interval.Ropen(0, 2*pi)
+    >>> normalize_theta_set(Interval(-pi/2, pi/2))
+    Union(Interval(0, pi/2), Interval.Ropen(3*pi/2, 2*pi))
+    >>> normalize_theta_set(Interval(-4*pi, 3*pi))
+    Interval.Ropen(0, 2*pi)
+    >>> normalize_theta_set(Interval(-3*pi/2, -pi/2))
+    Interval(pi/2, 3*pi/2)
+    >>> normalize_theta_set(FiniteSet(0, pi, 3*pi))
+    {0, pi}
+
+    """
+    from sympy.functions.elementary.trigonometric import _pi_coeff
+
+    if theta.is_Interval:
+        interval_len = theta.measure
+        # one complete circle
+        if interval_len >= 2*S.Pi:
+            if interval_len == 2*S.Pi and theta.left_open and theta.right_open:
+                k = _pi_coeff(theta.start)
+                return Union(Interval(0, k*S.Pi, False, True),
+                        Interval(k*S.Pi, 2*S.Pi, True, True))
+            return Interval(0, 2*S.Pi, False, True)
+
+        k_start, k_end = _pi_coeff(theta.start), _pi_coeff(theta.end)
+
+        if k_start is None or k_end is None:
+            raise NotImplementedError("Normalizing theta without pi as coefficient is "
+                                    "not yet implemented")
+        new_start = k_start*S.Pi
+        new_end = k_end*S.Pi
+
+        if new_start > new_end:
+            return Union(Interval(S.Zero, new_end, False, theta.right_open),
+                         Interval(new_start, 2*S.Pi, theta.left_open, True))
+        else:
+            return Interval(new_start, new_end, theta.left_open, theta.right_open)
+
+    elif theta.is_FiniteSet:
+        new_theta = []
+        for element in theta:
+            k = _pi_coeff(element)
+            if k is None:
+                raise NotImplementedError('Normalizing theta without pi as '
+                                          'coefficient, is not Implemented.')
+            else:
+                new_theta.append(k*S.Pi)
+        return FiniteSet(*new_theta)
+
+    elif theta.is_Union:
+        return Union(*[normalize_theta_set(interval) for interval in theta.args])
+
+    elif theta.is_subset(S.Reals):
+        raise NotImplementedError("Normalizing theta when, it is of type %s is not "
+                                  "implemented" % type(theta))
+    else:
+        raise ValueError(" %s is not a real set" % (theta))
+
+
+class ComplexRegion(Set):
+    r"""
+    Represents the Set of all Complex Numbers. It can represent a
+    region of Complex Plane in both the standard forms Polar and
+    Rectangular coordinates.
+
+    * Polar Form
+      Input is in the form of the ProductSet or Union of ProductSets
+      of the intervals of ``r`` and ``theta``, and use the flag ``polar=True``.
+
+      .. math:: Z = \{z \in \mathbb{C} \mid z = r\times (\cos(\theta) + I\sin(\theta)), r \in [\texttt{r}], \theta \in [\texttt{theta}]\}
+
+    * Rectangular Form
+      Input is in the form of the ProductSet or Union of ProductSets
+      of interval of x and y, the real and imaginary parts of the Complex numbers in a plane.
+      Default input type is in rectangular form.
+
+    .. math:: Z = \{z \in \mathbb{C} \mid z = x + Iy, x \in [\operatorname{re}(z)], y \in [\operatorname{im}(z)]\}
+
+    Examples
+    ========
+
+    >>> from sympy import ComplexRegion, Interval, S, I, Union
+    >>> a = Interval(2, 3)
+    >>> b = Interval(4, 6)
+    >>> c1 = ComplexRegion(a*b)  # Rectangular Form
+    >>> c1
+    CartesianComplexRegion(ProductSet(Interval(2, 3), Interval(4, 6)))
+
+    * c1 represents the rectangular region in complex plane
+      surrounded by the coordinates (2, 4), (3, 4), (3, 6) and
+      (2, 6), of the four vertices.
+
+    >>> c = Interval(1, 8)
+    >>> c2 = ComplexRegion(Union(a*b, b*c))
+    >>> c2
+    CartesianComplexRegion(Union(ProductSet(Interval(2, 3), Interval(4, 6)), ProductSet(Interval(4, 6), Interval(1, 8))))
+
+    * c2 represents the Union of two rectangular regions in complex
+      plane. One of them surrounded by the coordinates of c1 and
+      other surrounded by the coordinates (4, 1), (6, 1), (6, 8) and
+      (4, 8).
+
+    >>> 2.5 + 4.5*I in c1
+    True
+    >>> 2.5 + 6.5*I in c1
+    False
+
+    >>> r = Interval(0, 1)
+    >>> theta = Interval(0, 2*S.Pi)
+    >>> c2 = ComplexRegion(r*theta, polar=True)  # Polar Form
+    >>> c2  # unit Disk
+    PolarComplexRegion(ProductSet(Interval(0, 1), Interval.Ropen(0, 2*pi)))
+
+    * c2 represents the region in complex plane inside the
+      Unit Disk centered at the origin.
+
+    >>> 0.5 + 0.5*I in c2
+    True
+    >>> 1 + 2*I in c2
+    False
+
+    >>> unit_disk = ComplexRegion(Interval(0, 1)*Interval(0, 2*S.Pi), polar=True)
+    >>> upper_half_unit_disk = ComplexRegion(Interval(0, 1)*Interval(0, S.Pi), polar=True)
+    >>> intersection = unit_disk.intersect(upper_half_unit_disk)
+    >>> intersection
+    PolarComplexRegion(ProductSet(Interval(0, 1), Interval(0, pi)))
+    >>> intersection == upper_half_unit_disk
+    True
+
+    See Also
+    ========
+
+    CartesianComplexRegion
+    PolarComplexRegion
+    Complexes
+
+    """
+    is_ComplexRegion = True
+
+    def __new__(cls, sets, polar=False):
+        if polar is False:
+            return CartesianComplexRegion(sets)
+        elif polar is True:
+            return PolarComplexRegion(sets)
+        else:
+            raise ValueError("polar should be either True or False")
+
+    @property
+    def sets(self):
+        """
+        Return raw input sets to the self.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, ComplexRegion, Union
+        >>> a = Interval(2, 3)
+        >>> b = Interval(4, 5)
+        >>> c = Interval(1, 7)
+        >>> C1 = ComplexRegion(a*b)
+        >>> C1.sets
+        ProductSet(Interval(2, 3), Interval(4, 5))
+        >>> C2 = ComplexRegion(Union(a*b, b*c))
+        >>> C2.sets
+        Union(ProductSet(Interval(2, 3), Interval(4, 5)), ProductSet(Interval(4, 5), Interval(1, 7)))
+
+        """
+        return self.args[0]
+
+    @property
+    def psets(self):
+        """
+        Return a tuple of sets (ProductSets) input of the self.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, ComplexRegion, Union
+        >>> a = Interval(2, 3)
+        >>> b = Interval(4, 5)
+        >>> c = Interval(1, 7)
+        >>> C1 = ComplexRegion(a*b)
+        >>> C1.psets
+        (ProductSet(Interval(2, 3), Interval(4, 5)),)
+        >>> C2 = ComplexRegion(Union(a*b, b*c))
+        >>> C2.psets
+        (ProductSet(Interval(2, 3), Interval(4, 5)), ProductSet(Interval(4, 5), Interval(1, 7)))
+
+        """
+        if self.sets.is_ProductSet:
+            psets = ()
+            psets = psets + (self.sets, )
+        else:
+            psets = self.sets.args
+        return psets
+
+    @property
+    def a_interval(self):
+        """
+        Return the union of intervals of `x` when, self is in
+        rectangular form, or the union of intervals of `r` when
+        self is in polar form.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, ComplexRegion, Union
+        >>> a = Interval(2, 3)
+        >>> b = Interval(4, 5)
+        >>> c = Interval(1, 7)
+        >>> C1 = ComplexRegion(a*b)
+        >>> C1.a_interval
+        Interval(2, 3)
+        >>> C2 = ComplexRegion(Union(a*b, b*c))
+        >>> C2.a_interval
+        Union(Interval(2, 3), Interval(4, 5))
+
+        """
+        a_interval = []
+        for element in self.psets:
+            a_interval.append(element.args[0])
+
+        a_interval = Union(*a_interval)
+        return a_interval
+
+    @property
+    def b_interval(self):
+        """
+        Return the union of intervals of `y` when, self is in
+        rectangular form, or the union of intervals of `theta`
+        when self is in polar form.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, ComplexRegion, Union
+        >>> a = Interval(2, 3)
+        >>> b = Interval(4, 5)
+        >>> c = Interval(1, 7)
+        >>> C1 = ComplexRegion(a*b)
+        >>> C1.b_interval
+        Interval(4, 5)
+        >>> C2 = ComplexRegion(Union(a*b, b*c))
+        >>> C2.b_interval
+        Interval(1, 7)
+
+        """
+        b_interval = []
+        for element in self.psets:
+            b_interval.append(element.args[1])
+
+        b_interval = Union(*b_interval)
+        return b_interval
+
+    @property
+    def _measure(self):
+        """
+        The measure of self.sets.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, ComplexRegion, S
+        >>> a, b = Interval(2, 5), Interval(4, 8)
+        >>> c = Interval(0, 2*S.Pi)
+        >>> c1 = ComplexRegion(a*b)
+        >>> c1.measure
+        12
+        >>> c2 = ComplexRegion(a*c, polar=True)
+        >>> c2.measure
+        6*pi
+
+        """
+        return self.sets._measure
+
+    def _kind(self):
+        return self.args[0].kind
+
+    @classmethod
+    def from_real(cls, sets):
+        """
+        Converts given subset of real numbers to a complex region.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, ComplexRegion
+        >>> unit = Interval(0,1)
+        >>> ComplexRegion.from_real(unit)
+        CartesianComplexRegion(ProductSet(Interval(0, 1), {0}))
+
+        """
+        if not sets.is_subset(S.Reals):
+            raise ValueError("sets must be a subset of the real line")
+
+        return CartesianComplexRegion(sets * FiniteSet(0))
+
+    def _contains(self, other):
+        from sympy.functions import arg, Abs
+        other = sympify(other)
+        isTuple = isinstance(other, Tuple)
+        if isTuple and len(other) != 2:
+            raise ValueError('expecting Tuple of length 2')
+
+        # If the other is not an Expression, and neither a Tuple
+        if not isinstance(other, (Expr, Tuple)):
+            return S.false
+        # self in rectangular form
+        if not self.polar:
+            re, im = other if isTuple else other.as_real_imag()
+            return fuzzy_or(fuzzy_and([
+                pset.args[0]._contains(re),
+                pset.args[1]._contains(im)])
+                for pset in self.psets)
+
+        # self in polar form
+        elif self.polar:
+            if other.is_zero:
+                # ignore undefined complex argument
+                return fuzzy_or(pset.args[0]._contains(S.Zero)
+                    for pset in self.psets)
+            if isTuple:
+                r, theta = other
+            else:
+                r, theta = Abs(other), arg(other)
+            if theta.is_real and theta.is_number:
+                # angles in psets are normalized to [0, 2pi)
+                theta %= 2*S.Pi
+                return fuzzy_or(fuzzy_and([
+                    pset.args[0]._contains(r),
+                    pset.args[1]._contains(theta)])
+                    for pset in self.psets)
+
+
+class CartesianComplexRegion(ComplexRegion):
+    r"""
+    Set representing a square region of the complex plane.
+
+    .. math:: Z = \{z \in \mathbb{C} \mid z = x + Iy, x \in [\operatorname{re}(z)], y \in [\operatorname{im}(z)]\}
+
+    Examples
+    ========
+
+    >>> from sympy import ComplexRegion, I, Interval
+    >>> region = ComplexRegion(Interval(1, 3) * Interval(4, 6))
+    >>> 2 + 5*I in region
+    True
+    >>> 5*I in region
+    False
+
+    See also
+    ========
+
+    ComplexRegion
+    PolarComplexRegion
+    Complexes
+    """
+
+    polar = False
+    variables = symbols('x, y', cls=Dummy)
+
+    def __new__(cls, sets):
+
+        if sets == S.Reals*S.Reals:
+            return S.Complexes
+
+        if all(_a.is_FiniteSet for _a in sets.args) and (len(sets.args) == 2):
+
+            # ** ProductSet of FiniteSets in the Complex Plane. **
+            # For Cases like ComplexRegion({2, 4}*{3}), It
+            # would return {2 + 3*I, 4 + 3*I}
+
+            # FIXME: This should probably be handled with something like:
+            # return ImageSet(Lambda((x, y), x+I*y), sets).rewrite(FiniteSet)
+            complex_num = []
+            for x in sets.args[0]:
+                for y in sets.args[1]:
+                    complex_num.append(x + S.ImaginaryUnit*y)
+            return FiniteSet(*complex_num)
+        else:
+            return Set.__new__(cls, sets)
+
+    @property
+    def expr(self):
+        x, y = self.variables
+        return x + S.ImaginaryUnit*y
+
+
+class PolarComplexRegion(ComplexRegion):
+    r"""
+    Set representing a polar region of the complex plane.
+
+    .. math:: Z = \{z \in \mathbb{C} \mid z = r\times (\cos(\theta) + I\sin(\theta)), r \in [\texttt{r}], \theta \in [\texttt{theta}]\}
+
+    Examples
+    ========
+
+    >>> from sympy import ComplexRegion, Interval, oo, pi, I
+    >>> rset = Interval(0, oo)
+    >>> thetaset = Interval(0, pi)
+    >>> upper_half_plane = ComplexRegion(rset * thetaset, polar=True)
+    >>> 1 + I in upper_half_plane
+    True
+    >>> 1 - I in upper_half_plane
+    False
+
+    See also
+    ========
+
+    ComplexRegion
+    CartesianComplexRegion
+    Complexes
+
+    """
+
+    polar = True
+    variables = symbols('r, theta', cls=Dummy)
+
+    def __new__(cls, sets):
+
+        new_sets = []
+        # sets is Union of ProductSets
+        if not sets.is_ProductSet:
+            for k in sets.args:
+                new_sets.append(k)
+        # sets is ProductSets
+        else:
+            new_sets.append(sets)
+        # Normalize input theta
+        for k, v in enumerate(new_sets):
+            new_sets[k] = ProductSet(v.args[0],
+                                     normalize_theta_set(v.args[1]))
+        sets = Union(*new_sets)
+        return Set.__new__(cls, sets)
+
+    @property
+    def expr(self):
+        r, theta = self.variables
+        return r*(cos(theta) + S.ImaginaryUnit*sin(theta))
+
+
+class Complexes(CartesianComplexRegion, metaclass=Singleton):
+    """
+    The :class:`Set` of all complex numbers
+
+    Examples
+    ========
+
+    >>> from sympy import S, I
+    >>> S.Complexes
+    Complexes
+    >>> 1 + I in S.Complexes
+    True
+
+    See also
+    ========
+
+    Reals
+    ComplexRegion
+
+    """
+
+    is_empty = False
+    is_finite_set = False
+
+    # Override property from superclass since Complexes has no args
+    @property
+    def sets(self):
+        return ProductSet(S.Reals, S.Reals)
+
+    def __new__(cls):
+        return Set.__new__(cls)

env-llmeval/lib/python3.10/site-packages/sympy/sets/handlers/add.py

@@ -0,0 +1,79 @@
+from sympy.core.numbers import oo, Infinity, NegativeInfinity
+from sympy.core.singleton import S
+from sympy.core import Basic, Expr
+from sympy.multipledispatch import Dispatcher
+from sympy.sets import Interval, FiniteSet
+
+
+
+# XXX: The functions in this module are clearly not tested and are broken in a
+# number of ways.
+
+_set_add = Dispatcher('_set_add')
+_set_sub = Dispatcher('_set_sub')
+
+
+@_set_add.register(Basic, Basic)
+def _(x, y):
+    return None
+
+
+@_set_add.register(Expr, Expr)
+def _(x, y):
+    return x+y
+
+
+@_set_add.register(Interval, Interval)
+def _(x, y):
+    """
+    Additions in interval arithmetic
+    https://en.wikipedia.org/wiki/Interval_arithmetic
+    """
+    return Interval(x.start + y.start, x.end + y.end,
+                    x.left_open or y.left_open, x.right_open or y.right_open)
+
+
+@_set_add.register(Interval, Infinity)
+def _(x, y):
+    if x.start is S.NegativeInfinity:
+        return Interval(-oo, oo)
+    return FiniteSet({S.Infinity})
+
+@_set_add.register(Interval, NegativeInfinity)
+def _(x, y):
+    if x.end is S.Infinity:
+        return Interval(-oo, oo)
+    return FiniteSet({S.NegativeInfinity})
+
+
+@_set_sub.register(Basic, Basic)
+def _(x, y):
+    return None
+
+
+@_set_sub.register(Expr, Expr)
+def _(x, y):
+    return x-y
+
+
+@_set_sub.register(Interval, Interval)
+def _(x, y):
+    """
+    Subtractions in interval arithmetic
+    https://en.wikipedia.org/wiki/Interval_arithmetic
+    """
+    return Interval(x.start - y.end, x.end - y.start,
+                    x.left_open or y.right_open, x.right_open or y.left_open)
+
+
+@_set_sub.register(Interval, Infinity)
+def _(x, y):
+    if x.start is S.NegativeInfinity:
+        return Interval(-oo, oo)
+    return FiniteSet(-oo)
+
+@_set_sub.register(Interval, NegativeInfinity)
+def _(x, y):
+    if x.start is S.NegativeInfinity:
+        return Interval(-oo, oo)
+    return FiniteSet(-oo)

env-llmeval/lib/python3.10/site-packages/sympy/sets/handlers/comparison.py

@@ -0,0 +1,53 @@
+from sympy.core.relational import Eq, is_eq
+from sympy.core.basic import Basic
+from sympy.core.logic import fuzzy_and, fuzzy_bool
+from sympy.logic.boolalg import And
+from sympy.multipledispatch import dispatch
+from sympy.sets.sets import tfn, ProductSet, Interval, FiniteSet, Set
+
+
+@dispatch(Interval, FiniteSet) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    return False
+
+
+@dispatch(FiniteSet, Interval) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    return False
+
+
+@dispatch(Interval, Interval) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    return And(Eq(lhs.left, rhs.left),
+               Eq(lhs.right, rhs.right),
+               lhs.left_open == rhs.left_open,
+               lhs.right_open == rhs.right_open)
+
+@dispatch(FiniteSet, FiniteSet) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    def all_in_both():
+        s_set = set(lhs.args)
+        o_set = set(rhs.args)
+        yield fuzzy_and(lhs._contains(e) for e in o_set - s_set)
+        yield fuzzy_and(rhs._contains(e) for e in s_set - o_set)
+
+    return tfn[fuzzy_and(all_in_both())]
+
+
+@dispatch(ProductSet, ProductSet) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    if len(lhs.sets) != len(rhs.sets):
+        return False
+
+    eqs = (is_eq(x, y) for x, y in zip(lhs.sets, rhs.sets))
+    return tfn[fuzzy_and(map(fuzzy_bool, eqs))]
+
+
+@dispatch(Set, Basic) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    return False
+
+
+@dispatch(Set, Set) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    return tfn[fuzzy_and(a.is_subset(b) for a, b in [(lhs, rhs), (rhs, lhs)])]

env-llmeval/lib/python3.10/site-packages/sympy/sets/handlers/functions.py

@@ -0,0 +1,262 @@
+from sympy.core.singleton import S
+from sympy.sets.sets import Set
+from sympy.calculus.singularities import singularities
+from sympy.core import Expr, Add
+from sympy.core.function import Lambda, FunctionClass, diff, expand_mul
+from sympy.core.numbers import Float, oo
+from sympy.core.symbol import Dummy, symbols, Wild
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.miscellaneous import Min, Max
+from sympy.logic.boolalg import true
+from sympy.multipledispatch import Dispatcher
+from sympy.sets import (imageset, Interval, FiniteSet, Union, ImageSet,
+    Intersection, Range, Complement)
+from sympy.sets.sets import EmptySet, is_function_invertible_in_set
+from sympy.sets.fancysets import Integers, Naturals, Reals
+from sympy.functions.elementary.exponential import match_real_imag
+
+
+_x, _y = symbols("x y")
+
+FunctionUnion = (FunctionClass, Lambda)
+
+_set_function = Dispatcher('_set_function')
+
+
+@_set_function.register(FunctionClass, Set)
+def _(f, x):
+    return None
+
+@_set_function.register(FunctionUnion, FiniteSet)
+def _(f, x):
+    return FiniteSet(*map(f, x))
+
+@_set_function.register(Lambda, Interval)
+def _(f, x):
+    from sympy.solvers.solveset import solveset
+    from sympy.series import limit
+    # TODO: handle functions with infinitely many solutions (eg, sin, tan)
+    # TODO: handle multivariate functions
+
+    expr = f.expr
+    if len(expr.free_symbols) > 1 or len(f.variables) != 1:
+        return
+    var = f.variables[0]
+    if not var.is_real:
+        if expr.subs(var, Dummy(real=True)).is_real is False:
+            return
+
+    if expr.is_Piecewise:
+        result = S.EmptySet
+        domain_set = x
+        for (p_expr, p_cond) in expr.args:
+            if p_cond is true:
+                intrvl = domain_set
+            else:
+                intrvl = p_cond.as_set()
+                intrvl = Intersection(domain_set, intrvl)
+
+            if p_expr.is_Number:
+                image = FiniteSet(p_expr)
+            else:
+                image = imageset(Lambda(var, p_expr), intrvl)
+            result = Union(result, image)
+
+            # remove the part which has been `imaged`
+            domain_set = Complement(domain_set, intrvl)
+            if domain_set is S.EmptySet:
+                break
+        return result
+
+    if not x.start.is_comparable or not x.end.is_comparable:
+        return
+
+    try:
+        from sympy.polys.polyutils import _nsort
+        sing = list(singularities(expr, var, x))
+        if len(sing) > 1:
+            sing = _nsort(sing)
+    except NotImplementedError:
+        return
+
+    if x.left_open:
+        _start = limit(expr, var, x.start, dir="+")
+    elif x.start not in sing:
+        _start = f(x.start)
+    if x.right_open:
+        _end = limit(expr, var, x.end, dir="-")
+    elif x.end not in sing:
+        _end = f(x.end)
+
+    if len(sing) == 0:
+        soln_expr = solveset(diff(expr, var), var)
+        if not (isinstance(soln_expr, FiniteSet)
+                or soln_expr is S.EmptySet):
+            return
+        solns = list(soln_expr)
+
+        extr = [_start, _end] + [f(i) for i in solns
+                                 if i.is_real and i in x]
+        start, end = Min(*extr), Max(*extr)
+
+        left_open, right_open = False, False
+        if _start <= _end:
+            # the minimum or maximum value can occur simultaneously
+            # on both the edge of the interval and in some interior
+            # point
+            if start == _start and start not in solns:
+                left_open = x.left_open
+            if end == _end and end not in solns:
+                right_open = x.right_open
+        else:
+            if start == _end and start not in solns:
+                left_open = x.right_open
+            if end == _start and end not in solns:
+                right_open = x.left_open
+
+        return Interval(start, end, left_open, right_open)
+    else:
+        return imageset(f, Interval(x.start, sing[0],
+                                    x.left_open, True)) + \
+            Union(*[imageset(f, Interval(sing[i], sing[i + 1], True, True))
+                    for i in range(0, len(sing) - 1)]) + \
+            imageset(f, Interval(sing[-1], x.end, True, x.right_open))
+
+@_set_function.register(FunctionClass, Interval)
+def _(f, x):
+    if f == exp:
+        return Interval(exp(x.start), exp(x.end), x.left_open, x.right_open)
+    elif f == log:
+        return Interval(log(x.start), log(x.end), x.left_open, x.right_open)
+    return ImageSet(Lambda(_x, f(_x)), x)
+
+@_set_function.register(FunctionUnion, Union)
+def _(f, x):
+    return Union(*(imageset(f, arg) for arg in x.args))
+
+@_set_function.register(FunctionUnion, Intersection)
+def _(f, x):
+    # If the function is invertible, intersect the maps of the sets.
+    if is_function_invertible_in_set(f, x):
+        return Intersection(*(imageset(f, arg) for arg in x.args))
+    else:
+        return ImageSet(Lambda(_x, f(_x)), x)
+
+@_set_function.register(FunctionUnion, EmptySet)
+def _(f, x):
+    return x
+
+@_set_function.register(FunctionUnion, Set)
+def _(f, x):
+    return ImageSet(Lambda(_x, f(_x)), x)
+
+@_set_function.register(FunctionUnion, Range)
+def _(f, self):
+    if not self:
+        return S.EmptySet
+    if not isinstance(f.expr, Expr):
+        return
+    if self.size == 1:
+        return FiniteSet(f(self[0]))
+    if f is S.IdentityFunction:
+        return self
+
+    x = f.variables[0]
+    expr = f.expr
+    # handle f that is linear in f's variable
+    if x not in expr.free_symbols or x in expr.diff(x).free_symbols:
+        return
+    if self.start.is_finite:
+        F = f(self.step*x + self.start)  # for i in range(len(self))
+    else:
+        F = f(-self.step*x + self[-1])
+    F = expand_mul(F)
+    if F != expr:
+        return imageset(x, F, Range(self.size))
+
+@_set_function.register(FunctionUnion, Integers)
+def _(f, self):
+    expr = f.expr
+    if not isinstance(expr, Expr):
+        return
+
+    n = f.variables[0]
+    if expr == abs(n):
+        return S.Naturals0
+
+    # f(x) + c and f(-x) + c cover the same integers
+    # so choose the form that has the fewest negatives
+    c = f(0)
+    fx = f(n) - c
+    f_x = f(-n) - c
+    neg_count = lambda e: sum(_.could_extract_minus_sign()
+        for _ in Add.make_args(e))
+    if neg_count(f_x) < neg_count(fx):
+        expr = f_x + c
+
+    a = Wild('a', exclude=[n])
+    b = Wild('b', exclude=[n])
+    match = expr.match(a*n + b)
+    if match and match[a] and (
+            not match[a].atoms(Float) and
+            not match[b].atoms(Float)):
+        # canonical shift
+        a, b = match[a], match[b]
+        if a in [1, -1]:
+            # drop integer addends in b
+            nonint = []
+            for bi in Add.make_args(b):
+                if not bi.is_integer:
+                    nonint.append(bi)
+            b = Add(*nonint)
+        if b.is_number and a.is_real:
+            # avoid Mod for complex numbers, #11391
+            br, bi = match_real_imag(b)
+            if br and br.is_comparable and a.is_comparable:
+                br %= a
+                b = br + S.ImaginaryUnit*bi
+        elif b.is_number and a.is_imaginary:
+            br, bi = match_real_imag(b)
+            ai = a/S.ImaginaryUnit
+            if bi and bi.is_comparable and ai.is_comparable:
+                bi %= ai
+                b = br + S.ImaginaryUnit*bi
+        expr = a*n + b
+
+    if expr != f.expr:
+        return ImageSet(Lambda(n, expr), S.Integers)
+
+
+@_set_function.register(FunctionUnion, Naturals)
+def _(f, self):
+    expr = f.expr
+    if not isinstance(expr, Expr):
+        return
+
+    x = f.variables[0]
+    if not expr.free_symbols - {x}:
+        if expr == abs(x):
+            if self is S.Naturals:
+                return self
+            return S.Naturals0
+        step = expr.coeff(x)
+        c = expr.subs(x, 0)
+        if c.is_Integer and step.is_Integer and expr == step*x + c:
+            if self is S.Naturals:
+                c += step
+            if step > 0:
+                if step == 1:
+                    if c == 0:
+                        return S.Naturals0
+                    elif c == 1:
+                        return S.Naturals
+                return Range(c, oo, step)
+            return Range(c, -oo, step)
+
+
+@_set_function.register(FunctionUnion, Reals)
+def _(f, self):
+    expr = f.expr
+    if not isinstance(expr, Expr):
+        return
+    return _set_function(f, Interval(-oo, oo))

env-llmeval/lib/python3.10/site-packages/sympy/sets/handlers/intersection.py

@@ -0,0 +1,514 @@
+from sympy.core.function import Lambda, expand_complex
+from sympy.core.mul import Mul
+from sympy.core.numbers import ilcm
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.core.sorting import ordered
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.integers import floor, ceiling
+from sympy.sets.fancysets import ComplexRegion
+from sympy.sets.sets import (FiniteSet, Intersection, Interval, Set, Union)
+from sympy.multipledispatch import Dispatcher
+from sympy.sets.conditionset import ConditionSet
+from sympy.sets.fancysets import (Integers, Naturals, Reals, Range,
+    ImageSet, Rationals)
+from sympy.sets.sets import EmptySet, UniversalSet, imageset, ProductSet
+from sympy.simplify.radsimp import numer
+
+
+intersection_sets = Dispatcher('intersection_sets')
+
+
+@intersection_sets.register(ConditionSet, ConditionSet)
+def _(a, b):
+    return None
+
+@intersection_sets.register(ConditionSet, Set)
+def _(a, b):
+    return ConditionSet(a.sym, a.condition, Intersection(a.base_set, b))
+
+@intersection_sets.register(Naturals, Integers)
+def _(a, b):
+    return a
+
+@intersection_sets.register(Naturals, Naturals)
+def _(a, b):
+    return a if a is S.Naturals else b
+
+@intersection_sets.register(Interval, Naturals)
+def _(a, b):
+    return intersection_sets(b, a)
+
+@intersection_sets.register(ComplexRegion, Set)
+def _(self, other):
+    if other.is_ComplexRegion:
+        # self in rectangular form
+        if (not self.polar) and (not other.polar):
+            return ComplexRegion(Intersection(self.sets, other.sets))
+
+        # self in polar form
+        elif self.polar and other.polar:
+            r1, theta1 = self.a_interval, self.b_interval
+            r2, theta2 = other.a_interval, other.b_interval
+            new_r_interval = Intersection(r1, r2)
+            new_theta_interval = Intersection(theta1, theta2)
+
+            # 0 and 2*Pi means the same
+            if ((2*S.Pi in theta1 and S.Zero in theta2) or
+               (2*S.Pi in theta2 and S.Zero in theta1)):
+                new_theta_interval = Union(new_theta_interval,
+                                           FiniteSet(0))
+            return ComplexRegion(new_r_interval*new_theta_interval,
+                                polar=True)
+
+
+    if other.is_subset(S.Reals):
+        new_interval = []
+        x = symbols("x", cls=Dummy, real=True)
+
+        # self in rectangular form
+        if not self.polar:
+            for element in self.psets:
+                if S.Zero in element.args[1]:
+                    new_interval.append(element.args[0])
+            new_interval = Union(*new_interval)
+            return Intersection(new_interval, other)
+
+        # self in polar form
+        elif self.polar:
+            for element in self.psets:
+                if S.Zero in element.args[1]:
+                    new_interval.append(element.args[0])
+                if S.Pi in element.args[1]:
+                    new_interval.append(ImageSet(Lambda(x, -x), element.args[0]))
+                if S.Zero in element.args[0]:
+                    new_interval.append(FiniteSet(0))
+            new_interval = Union(*new_interval)
+            return Intersection(new_interval, other)
+
+@intersection_sets.register(Integers, Reals)
+def _(a, b):
+    return a
+
+@intersection_sets.register(Range, Interval)
+def _(a, b):
+    # Check that there are no symbolic arguments
+    if not all(i.is_number for i in a.args + b.args[:2]):
+        return
+
+    # In case of null Range, return an EmptySet.
+    if a.size == 0:
+        return S.EmptySet
+
+    # trim down to self's size, and represent
+    # as a Range with step 1.
+    start = ceiling(max(b.inf, a.inf))
+    if start not in b:
+        start += 1
+    end = floor(min(b.sup, a.sup))
+    if end not in b:
+        end -= 1
+    return intersection_sets(a, Range(start, end + 1))
+
+@intersection_sets.register(Range, Naturals)
+def _(a, b):
+    return intersection_sets(a, Interval(b.inf, S.Infinity))
+
+@intersection_sets.register(Range, Range)
+def _(a, b):
+    # Check that there are no symbolic range arguments
+    if not all(all(v.is_number for v in r.args) for r in [a, b]):
+        return None
+
+    # non-overlap quick exits
+    if not b:
+        return S.EmptySet
+    if not a:
+        return S.EmptySet
+    if b.sup < a.inf:
+        return S.EmptySet
+    if b.inf > a.sup:
+        return S.EmptySet
+
+    # work with finite end at the start
+    r1 = a
+    if r1.start.is_infinite:
+        r1 = r1.reversed
+    r2 = b
+    if r2.start.is_infinite:
+        r2 = r2.reversed
+
+    # If both ends are infinite then it means that one Range is just the set
+    # of all integers (the step must be 1).
+    if r1.start.is_infinite:
+        return b
+    if r2.start.is_infinite:
+        return a
+
+    from sympy.solvers.diophantine.diophantine import diop_linear
+
+    # this equation represents the values of the Range;
+    # it's a linear equation
+    eq = lambda r, i: r.start + i*r.step
+
+    # we want to know when the two equations might
+    # have integer solutions so we use the diophantine
+    # solver
+    va, vb = diop_linear(eq(r1, Dummy('a')) - eq(r2, Dummy('b')))
+
+    # check for no solution
+    no_solution = va is None and vb is None
+    if no_solution:
+        return S.EmptySet
+
+    # there is a solution
+    # -------------------
+
+    # find the coincident point, c
+    a0 = va.as_coeff_Add()[0]
+    c = eq(r1, a0)
+
+    # find the first point, if possible, in each range
+    # since c may not be that point
+    def _first_finite_point(r1, c):
+        if c == r1.start:
+            return c
+        # st is the signed step we need to take to
+        # get from c to r1.start
+        st = sign(r1.start - c)*step
+        # use Range to calculate the first point:
+        # we want to get as close as possible to
+        # r1.start; the Range will not be null since
+        # it will at least contain c
+        s1 = Range(c, r1.start + st, st)[-1]
+        if s1 == r1.start:
+            pass
+        else:
+            # if we didn't hit r1.start then, if the
+            # sign of st didn't match the sign of r1.step
+            # we are off by one and s1 is not in r1
+            if sign(r1.step) != sign(st):
+                s1 -= st
+        if s1 not in r1:
+            return
+        return s1
+
+    # calculate the step size of the new Range
+    step = abs(ilcm(r1.step, r2.step))
+    s1 = _first_finite_point(r1, c)
+    if s1 is None:
+        return S.EmptySet
+    s2 = _first_finite_point(r2, c)
+    if s2 is None:
+        return S.EmptySet
+
+    # replace the corresponding start or stop in
+    # the original Ranges with these points; the
+    # result must have at least one point since
+    # we know that s1 and s2 are in the Ranges
+    def _updated_range(r, first):
+        st = sign(r.step)*step
+        if r.start.is_finite:
+            rv = Range(first, r.stop, st)
+        else:
+            rv = Range(r.start, first + st, st)
+        return rv
+    r1 = _updated_range(a, s1)
+    r2 = _updated_range(b, s2)
+
+    # work with them both in the increasing direction
+    if sign(r1.step) < 0:
+        r1 = r1.reversed
+    if sign(r2.step) < 0:
+        r2 = r2.reversed
+
+    # return clipped Range with positive step; it
+    # can't be empty at this point
+    start = max(r1.start, r2.start)
+    stop = min(r1.stop, r2.stop)
+    return Range(start, stop, step)
+
+
+@intersection_sets.register(Range, Integers)
+def _(a, b):
+    return a
+
+
+@intersection_sets.register(Range, Rationals)
+def _(a, b):
+    return a
+
+
+@intersection_sets.register(ImageSet, Set)
+def _(self, other):
+    from sympy.solvers.diophantine import diophantine
+
+    # Only handle the straight-forward univariate case
+    if (len(self.lamda.variables) > 1
+            or self.lamda.signature != self.lamda.variables):
+        return None
+    base_set = self.base_sets[0]
+
+    # Intersection between ImageSets with Integers as base set
+    # For {f(n) : n in Integers} & {g(m) : m in Integers} we solve the
+    # diophantine equations f(n)=g(m).
+    # If the solutions for n are {h(t) : t in Integers} then we return
+    # {f(h(t)) : t in integers}.
+    # If the solutions for n are {n_1, n_2, ..., n_k} then we return
+    # {f(n_i) : 1 <= i <= k}.
+    if base_set is S.Integers:
+        gm = None
+        if isinstance(other, ImageSet) and other.base_sets == (S.Integers,):
+            gm = other.lamda.expr
+            var = other.lamda.variables[0]
+            # Symbol of second ImageSet lambda must be distinct from first
+            m = Dummy('m')
+            gm = gm.subs(var, m)
+        elif other is S.Integers:
+            m = gm = Dummy('m')
+        if gm is not None:
+            fn = self.lamda.expr
+            n = self.lamda.variables[0]
+            try:
+                solns = list(diophantine(fn - gm, syms=(n, m), permute=True))
+            except (TypeError, NotImplementedError):
+                # TypeError if equation not polynomial with rational coeff.
+                # NotImplementedError if correct format but no solver.
+                return
+            # 3 cases are possible for solns:
+            # - empty set,
+            # - one or more parametric (infinite) solutions,
+            # - a finite number of (non-parametric) solution couples.
+            # Among those, there is one type of solution set that is
+            # not helpful here: multiple parametric solutions.
+            if len(solns) == 0:
+                return S.EmptySet
+            elif any(s.free_symbols for tupl in solns for s in tupl):
+                if len(solns) == 1:
+                    soln, solm = solns[0]
+                    (t,) = soln.free_symbols
+                    expr = fn.subs(n, soln.subs(t, n)).expand()
+                    return imageset(Lambda(n, expr), S.Integers)
+                else:
+                    return
+            else:
+                return FiniteSet(*(fn.subs(n, s[0]) for s in solns))
+
+    if other == S.Reals:
+        from sympy.solvers.solvers import denoms, solve_linear
+
+        def _solution_union(exprs, sym):
+            # return a union of linear solutions to i in expr;
+            # if i cannot be solved, use a ConditionSet for solution
+            sols = []
+            for i in exprs:
+                x, xis = solve_linear(i, 0, [sym])
+                if x == sym:
+                    sols.append(FiniteSet(xis))
+                else:
+                    sols.append(ConditionSet(sym, Eq(i, 0)))
+            return Union(*sols)
+
+        f = self.lamda.expr
+        n = self.lamda.variables[0]
+
+        n_ = Dummy(n.name, real=True)
+        f_ = f.subs(n, n_)
+
+        re, im = f_.as_real_imag()
+        im = expand_complex(im)
+
+        re = re.subs(n_, n)
+        im = im.subs(n_, n)
+        ifree = im.free_symbols
+        lam = Lambda(n, re)
+        if im.is_zero:
+            # allow re-evaluation
+            # of self in this case to make
+            # the result canonical
+            pass
+        elif im.is_zero is False:
+            return S.EmptySet
+        elif ifree != {n}:
+            return None
+        else:
+            # univarite imaginary part in same variable;
+            # use numer instead of as_numer_denom to keep
+            # this as fast as possible while still handling
+            # simple cases
+            base_set &= _solution_union(
+                Mul.make_args(numer(im)), n)
+        # exclude values that make denominators 0
+        base_set -= _solution_union(denoms(f), n)
+        return imageset(lam, base_set)
+
+    elif isinstance(other, Interval):
+        from sympy.solvers.solveset import (invert_real, invert_complex,
+                                            solveset)
+
+        f = self.lamda.expr
+        n = self.lamda.variables[0]
+        new_inf, new_sup = None, None
+        new_lopen, new_ropen = other.left_open, other.right_open
+
+        if f.is_real:
+            inverter = invert_real
+        else:
+            inverter = invert_complex
+
+        g1, h1 = inverter(f, other.inf, n)
+        g2, h2 = inverter(f, other.sup, n)
+
+        if all(isinstance(i, FiniteSet) for i in (h1, h2)):
+            if g1 == n:
+                if len(h1) == 1:
+                    new_inf = h1.args[0]
+            if g2 == n:
+                if len(h2) == 1:
+                    new_sup = h2.args[0]
+            # TODO: Design a technique to handle multiple-inverse
+            # functions
+
+            # Any of the new boundary values cannot be determined
+            if any(i is None for i in (new_sup, new_inf)):
+                return
+
+
+            range_set = S.EmptySet
+
+            if all(i.is_real for i in (new_sup, new_inf)):
+                # this assumes continuity of underlying function
+                # however fixes the case when it is decreasing
+                if new_inf > new_sup:
+                    new_inf, new_sup = new_sup, new_inf
+                new_interval = Interval(new_inf, new_sup, new_lopen, new_ropen)
+                range_set = base_set.intersect(new_interval)
+            else:
+                if other.is_subset(S.Reals):
+                    solutions = solveset(f, n, S.Reals)
+                    if not isinstance(range_set, (ImageSet, ConditionSet)):
+                        range_set = solutions.intersect(other)
+                    else:
+                        return
+
+            if range_set is S.EmptySet:
+                return S.EmptySet
+            elif isinstance(range_set, Range) and range_set.size is not S.Infinity:
+                range_set = FiniteSet(*list(range_set))
+
+            if range_set is not None:
+                return imageset(Lambda(n, f), range_set)
+            return
+        else:
+            return
+
+
+@intersection_sets.register(ProductSet, ProductSet)
+def _(a, b):
+    if len(b.args) != len(a.args):
+        return S.EmptySet
+    return ProductSet(*(i.intersect(j) for i, j in zip(a.sets, b.sets)))
+
+
+@intersection_sets.register(Interval, Interval)
+def _(a, b):
+    # handle (-oo, oo)
+    infty = S.NegativeInfinity, S.Infinity
+    if a == Interval(*infty):
+        l, r = a.left, a.right
+        if l.is_real or l in infty or r.is_real or r in infty:
+            return b
+
+    # We can't intersect [0,3] with [x,6] -- we don't know if x>0 or x<0
+    if not a._is_comparable(b):
+        return None
+
+    empty = False
+
+    if a.start <= b.end and b.start <= a.end:
+        # Get topology right.
+        if a.start < b.start:
+            start = b.start
+            left_open = b.left_open
+        elif a.start > b.start:
+            start = a.start
+            left_open = a.left_open
+        else:
+            #this is to ensure that if Eq(a.start,b.start) but
+            #type(a.start) != type(b.start) the order of a and b
+            #does not matter for the result
+            start = list(ordered([a,b]))[0].start
+            left_open = a.left_open or b.left_open
+
+        if a.end < b.end:
+            end = a.end
+            right_open = a.right_open
+        elif a.end > b.end:
+            end = b.end
+            right_open = b.right_open
+        else:
+            end = list(ordered([a,b]))[0].end
+            right_open = a.right_open or b.right_open
+
+        if end - start == 0 and (left_open or right_open):
+            empty = True
+    else:
+        empty = True
+
+    if empty:
+        return S.EmptySet
+
+    return Interval(start, end, left_open, right_open)
+
+@intersection_sets.register(EmptySet, Set)
+def _(a, b):
+    return S.EmptySet
+
+@intersection_sets.register(UniversalSet, Set)
+def _(a, b):
+    return b
+
+@intersection_sets.register(FiniteSet, FiniteSet)
+def _(a, b):
+    return FiniteSet(*(a._elements & b._elements))
+
+@intersection_sets.register(FiniteSet, Set)
+def _(a, b):
+    try:
+        return FiniteSet(*[el for el in a if el in b])
+    except TypeError:
+        return None  # could not evaluate `el in b` due to symbolic ranges.
+
+@intersection_sets.register(Set, Set)
+def _(a, b):
+    return None
+
+@intersection_sets.register(Integers, Rationals)
+def _(a, b):
+    return a
+
+@intersection_sets.register(Naturals, Rationals)
+def _(a, b):
+    return a
+
+@intersection_sets.register(Rationals, Reals)
+def _(a, b):
+    return a
+
+def _intlike_interval(a, b):
+    try:
+        if b._inf is S.NegativeInfinity and b._sup is S.Infinity:
+            return a
+        s = Range(max(a.inf, ceiling(b.left)), floor(b.right) + 1)
+        return intersection_sets(s, b)  # take out endpoints if open interval
+    except ValueError:
+        return None
+
+@intersection_sets.register(Integers, Interval)
+def _(a, b):
+    return _intlike_interval(a, b)
+
+@intersection_sets.register(Naturals, Interval)
+def _(a, b):
+    return _intlike_interval(a, b)

env-llmeval/lib/python3.10/site-packages/sympy/sets/handlers/issubset.py

@@ -0,0 +1,144 @@
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.logic import fuzzy_and, fuzzy_bool, fuzzy_not, fuzzy_or
+from sympy.core.relational import Eq
+from sympy.sets.sets import FiniteSet, Interval, Set, Union, ProductSet
+from sympy.sets.fancysets import Complexes, Reals, Range, Rationals
+from sympy.multipledispatch import Dispatcher
+
+
+_inf_sets = [S.Naturals, S.Naturals0, S.Integers, S.Rationals, S.Reals, S.Complexes]
+
+
+is_subset_sets = Dispatcher('is_subset_sets')
+
+
+@is_subset_sets.register(Set, Set)
+def _(a, b):
+    return None
+
+@is_subset_sets.register(Interval, Interval)
+def _(a, b):
+    # This is correct but can be made more comprehensive...
+    if fuzzy_bool(a.start < b.start):
+        return False
+    if fuzzy_bool(a.end > b.end):
+        return False
+    if (b.left_open and not a.left_open and fuzzy_bool(Eq(a.start, b.start))):
+        return False
+    if (b.right_open and not a.right_open and fuzzy_bool(Eq(a.end, b.end))):
+        return False
+
+@is_subset_sets.register(Interval, FiniteSet)
+def _(a_interval, b_fs):
+    # An Interval can only be a subset of a finite set if it is finite
+    # which can only happen if it has zero measure.
+    if fuzzy_not(a_interval.measure.is_zero):
+        return False
+
+@is_subset_sets.register(Interval, Union)
+def _(a_interval, b_u):
+    if all(isinstance(s, (Interval, FiniteSet)) for s in b_u.args):
+        intervals = [s for s in b_u.args if isinstance(s, Interval)]
+        if all(fuzzy_bool(a_interval.start < s.start) for s in intervals):
+            return False
+        if all(fuzzy_bool(a_interval.end > s.end) for s in intervals):
+            return False
+        if a_interval.measure.is_nonzero:
+            no_overlap = lambda s1, s2: fuzzy_or([
+                    fuzzy_bool(s1.end <= s2.start),
+                    fuzzy_bool(s1.start >= s2.end),
+                    ])
+            if all(no_overlap(s, a_interval) for s in intervals):
+                return False
+
+@is_subset_sets.register(Range, Range)
+def _(a, b):
+    if a.step == b.step == 1:
+        return fuzzy_and([fuzzy_bool(a.start >= b.start),
+                          fuzzy_bool(a.stop <= b.stop)])
+
+@is_subset_sets.register(Range, Interval)
+def _(a_range, b_interval):
+    if a_range.step.is_positive:
+        if b_interval.left_open and a_range.inf.is_finite:
+            cond_left = a_range.inf > b_interval.left
+        else:
+            cond_left = a_range.inf >= b_interval.left
+        if b_interval.right_open and a_range.sup.is_finite:
+            cond_right = a_range.sup < b_interval.right
+        else:
+            cond_right = a_range.sup <= b_interval.right
+        return fuzzy_and([cond_left, cond_right])
+
+@is_subset_sets.register(Range, FiniteSet)
+def _(a_range, b_finiteset):
+    try:
+        a_size = a_range.size
+    except ValueError:
+        # symbolic Range of unknown size
+        return None
+    if a_size > len(b_finiteset):
+        return False
+    elif any(arg.has(Symbol) for arg in a_range.args):
+        return fuzzy_and(b_finiteset.contains(x) for x in a_range)
+    else:
+        # Checking A \ B == EmptySet is more efficient than repeated naive
+        # membership checks on an arbitrary FiniteSet.
+        a_set = set(a_range)
+        b_remaining = len(b_finiteset)
+        # Symbolic expressions and numbers of unknown type (integer or not) are
+        # all counted as "candidates", i.e. *potentially* matching some a in
+        # a_range.
+        cnt_candidate = 0
+        for b in b_finiteset:
+            if b.is_Integer:
+                a_set.discard(b)
+            elif fuzzy_not(b.is_integer):
+                pass
+            else:
+                cnt_candidate += 1
+            b_remaining -= 1
+            if len(a_set) > b_remaining + cnt_candidate:
+                return False
+            if len(a_set) == 0:
+                return True
+        return None
+
+@is_subset_sets.register(Interval, Range)
+def _(a_interval, b_range):
+    if a_interval.measure.is_extended_nonzero:
+        return False
+
+@is_subset_sets.register(Interval, Rationals)
+def _(a_interval, b_rationals):
+    if a_interval.measure.is_extended_nonzero:
+        return False
+
+@is_subset_sets.register(Range, Complexes)
+def _(a, b):
+    return True
+
+@is_subset_sets.register(Complexes, Interval)
+def _(a, b):
+    return False
+
+@is_subset_sets.register(Complexes, Range)
+def _(a, b):
+    return False
+
+@is_subset_sets.register(Complexes, Rationals)
+def _(a, b):
+    return False
+
+@is_subset_sets.register(Rationals, Reals)
+def _(a, b):
+    return True
+
+@is_subset_sets.register(Rationals, Range)
+def _(a, b):
+    return False
+
+@is_subset_sets.register(ProductSet, FiniteSet)
+def _(a_ps, b_fs):
+    return fuzzy_and(b_fs.contains(x) for x in a_ps)

env-llmeval/lib/python3.10/site-packages/sympy/sets/handlers/mul.py

@@ -0,0 +1,79 @@
+from sympy.core import Basic, Expr
+from sympy.core.numbers import oo
+from sympy.core.symbol import symbols
+from sympy.multipledispatch import Dispatcher
+from sympy.sets.setexpr import set_mul
+from sympy.sets.sets import Interval, Set
+
+
+_x, _y = symbols("x y")
+
+
+_set_mul = Dispatcher('_set_mul')
+_set_div = Dispatcher('_set_div')
+
+
+@_set_mul.register(Basic, Basic)
+def _(x, y):
+    return None
+
+@_set_mul.register(Set, Set)
+def _(x, y):
+    return None
+
+@_set_mul.register(Expr, Expr)
+def _(x, y):
+    return x*y
+
+@_set_mul.register(Interval, Interval)
+def _(x, y):
+    """
+    Multiplications in interval arithmetic
+    https://en.wikipedia.org/wiki/Interval_arithmetic
+    """
+    # TODO: some intervals containing 0 and oo will fail as 0*oo returns nan.
+    comvals = (
+        (x.start * y.start, bool(x.left_open or y.left_open)),
+        (x.start * y.end, bool(x.left_open or y.right_open)),
+        (x.end * y.start, bool(x.right_open or y.left_open)),
+        (x.end * y.end, bool(x.right_open or y.right_open)),
+    )
+    # TODO: handle symbolic intervals
+    minval, minopen = min(comvals)
+    maxval, maxopen = max(comvals)
+    return Interval(
+        minval,
+        maxval,
+        minopen,
+        maxopen
+    )
+
+@_set_div.register(Basic, Basic)
+def _(x, y):
+    return None
+
+@_set_div.register(Expr, Expr)
+def _(x, y):
+    return x/y
+
+@_set_div.register(Set, Set)
+def _(x, y):
+    return None
+
+@_set_div.register(Interval, Interval)
+def _(x, y):
+    """
+    Divisions in interval arithmetic
+    https://en.wikipedia.org/wiki/Interval_arithmetic
+    """
+    if (y.start*y.end).is_negative:
+        return Interval(-oo, oo)
+    if y.start == 0:
+        s2 = oo
+    else:
+        s2 = 1/y.start
+    if y.end == 0:
+        s1 = -oo
+    else:
+        s1 = 1/y.end
+    return set_mul(x, Interval(s1, s2, y.right_open, y.left_open))

env-llmeval/lib/python3.10/site-packages/sympy/sets/handlers/power.py

@@ -0,0 +1,107 @@
+from sympy.core import Basic, Expr
+from sympy.core.function import Lambda
+from sympy.core.numbers import oo, Infinity, NegativeInfinity, Zero, Integer
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import (Max, Min)
+from sympy.sets.fancysets import ImageSet
+from sympy.sets.setexpr import set_div
+from sympy.sets.sets import Set, Interval, FiniteSet, Union
+from sympy.multipledispatch import Dispatcher
+
+
+_x, _y = symbols("x y")
+
+
+_set_pow = Dispatcher('_set_pow')
+
+
+@_set_pow.register(Basic, Basic)
+def _(x, y):
+    return None
+
+@_set_pow.register(Set, Set)
+def _(x, y):
+    return ImageSet(Lambda((_x, _y), (_x ** _y)), x, y)
+
+@_set_pow.register(Expr, Expr)
+def _(x, y):
+    return x**y
+
+@_set_pow.register(Interval, Zero)
+def _(x, z):
+    return FiniteSet(S.One)
+
+@_set_pow.register(Interval, Integer)
+def _(x, exponent):
+    """
+    Powers in interval arithmetic
+    https://en.wikipedia.org/wiki/Interval_arithmetic
+    """
+    s1 = x.start**exponent
+    s2 = x.end**exponent
+    if ((s2 > s1) if exponent > 0 else (x.end > -x.start)) == True:
+        left_open = x.left_open
+        right_open = x.right_open
+        # TODO: handle unevaluated condition.
+        sleft = s2
+    else:
+        # TODO: `s2 > s1` could be unevaluated.
+        left_open = x.right_open
+        right_open = x.left_open
+        sleft = s1
+
+    if x.start.is_positive:
+        return Interval(
+            Min(s1, s2),
+            Max(s1, s2), left_open, right_open)
+    elif x.end.is_negative:
+        return Interval(
+            Min(s1, s2),
+            Max(s1, s2), left_open, right_open)
+
+    # Case where x.start < 0 and x.end > 0:
+    if exponent.is_odd:
+        if exponent.is_negative:
+            if x.start.is_zero:
+                return Interval(s2, oo, x.right_open)
+            if x.end.is_zero:
+                return Interval(-oo, s1, True, x.left_open)
+            return Union(Interval(-oo, s1, True, x.left_open), Interval(s2, oo, x.right_open))
+        else:
+            return Interval(s1, s2, x.left_open, x.right_open)
+    elif exponent.is_even:
+        if exponent.is_negative:
+            if x.start.is_zero:
+                return Interval(s2, oo, x.right_open)
+            if x.end.is_zero:
+                return Interval(s1, oo, x.left_open)
+            return Interval(0, oo)
+        else:
+            return Interval(S.Zero, sleft, S.Zero not in x, left_open)
+
+@_set_pow.register(Interval, Infinity)
+def _(b, e):
+    # TODO: add logic for open intervals?
+    if b.start.is_nonnegative:
+        if b.end < 1:
+            return FiniteSet(S.Zero)
+        if b.start > 1:
+            return FiniteSet(S.Infinity)
+        return Interval(0, oo)
+    elif b.end.is_negative:
+        if b.start > -1:
+            return FiniteSet(S.Zero)
+        if b.end < -1:
+            return FiniteSet(-oo, oo)
+        return Interval(-oo, oo)
+    else:
+        if b.start > -1:
+            if b.end < 1:
+                return FiniteSet(S.Zero)
+            return Interval(0, oo)
+        return Interval(-oo, oo)
+
+@_set_pow.register(Interval, NegativeInfinity)
+def _(b, e):
+    return _set_pow(set_div(S.One, b), oo)

env-llmeval/lib/python3.10/site-packages/sympy/sets/handlers/union.py

@@ -0,0 +1,147 @@
+from sympy.core.singleton import S
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.miscellaneous import Min, Max
+from sympy.sets.sets import (EmptySet, FiniteSet, Intersection,
+    Interval, ProductSet, Set, Union, UniversalSet)
+from sympy.sets.fancysets import (ComplexRegion, Naturals, Naturals0,
+    Integers, Rationals, Reals)
+from sympy.multipledispatch import Dispatcher
+
+
+union_sets = Dispatcher('union_sets')
+
+
+@union_sets.register(Naturals0, Naturals)
+def _(a, b):
+    return a
+
+@union_sets.register(Rationals, Naturals)
+def _(a, b):
+    return a
+
+@union_sets.register(Rationals, Naturals0)
+def _(a, b):
+    return a
+
+@union_sets.register(Reals, Naturals)
+def _(a, b):
+    return a
+
+@union_sets.register(Reals, Naturals0)
+def _(a, b):
+    return a
+
+@union_sets.register(Reals, Rationals)
+def _(a, b):
+    return a
+
+@union_sets.register(Integers, Set)
+def _(a, b):
+    intersect = Intersection(a, b)
+    if intersect == a:
+        return b
+    elif intersect == b:
+        return a
+
+@union_sets.register(ComplexRegion, Set)
+def _(a, b):
+    if b.is_subset(S.Reals):
+        # treat a subset of reals as a complex region
+        b = ComplexRegion.from_real(b)
+
+    if b.is_ComplexRegion:
+        # a in rectangular form
+        if (not a.polar) and (not b.polar):
+            return ComplexRegion(Union(a.sets, b.sets))
+        # a in polar form
+        elif a.polar and b.polar:
+            return ComplexRegion(Union(a.sets, b.sets), polar=True)
+    return None
+
+@union_sets.register(EmptySet, Set)
+def _(a, b):
+    return b
+
+
+@union_sets.register(UniversalSet, Set)
+def _(a, b):
+    return a
+
+@union_sets.register(ProductSet, ProductSet)
+def _(a, b):
+    if b.is_subset(a):
+        return a
+    if len(b.sets) != len(a.sets):
+        return None
+    if len(a.sets) == 2:
+        a1, a2 = a.sets
+        b1, b2 = b.sets
+        if a1 == b1:
+            return a1 * Union(a2, b2)
+        if a2 == b2:
+            return Union(a1, b1) * a2
+    return None
+
+@union_sets.register(ProductSet, Set)
+def _(a, b):
+    if b.is_subset(a):
+        return a
+    return None
+
+@union_sets.register(Interval, Interval)
+def _(a, b):
+    if a._is_comparable(b):
+        # Non-overlapping intervals
+        end = Min(a.end, b.end)
+        start = Max(a.start, b.start)
+        if (end < start or
+           (end == start and (end not in a and end not in b))):
+            return None
+        else:
+            start = Min(a.start, b.start)
+            end = Max(a.end, b.end)
+
+            left_open = ((a.start != start or a.left_open) and
+                         (b.start != start or b.left_open))
+            right_open = ((a.end != end or a.right_open) and
+                          (b.end != end or b.right_open))
+            return Interval(start, end, left_open, right_open)
+
+@union_sets.register(Interval, UniversalSet)
+def _(a, b):
+    return S.UniversalSet
+
+@union_sets.register(Interval, Set)
+def _(a, b):
+    # If I have open end points and these endpoints are contained in b
+    # But only in case, when endpoints are finite. Because
+    # interval does not contain oo or -oo.
+    open_left_in_b_and_finite = (a.left_open and
+                                     sympify(b.contains(a.start)) is S.true and
+                                     a.start.is_finite)
+    open_right_in_b_and_finite = (a.right_open and
+                                      sympify(b.contains(a.end)) is S.true and
+                                      a.end.is_finite)
+    if open_left_in_b_and_finite or open_right_in_b_and_finite:
+        # Fill in my end points and return
+        open_left = a.left_open and a.start not in b
+        open_right = a.right_open and a.end not in b
+        new_a = Interval(a.start, a.end, open_left, open_right)
+        return {new_a, b}
+    return None
+
+@union_sets.register(FiniteSet, FiniteSet)
+def _(a, b):
+    return FiniteSet(*(a._elements | b._elements))
+
+@union_sets.register(FiniteSet, Set)
+def _(a, b):
+    # If `b` set contains one of my elements, remove it from `a`
+    if any(b.contains(x) == True for x in a):
+        return {
+            FiniteSet(*[x for x in a if b.contains(x) != True]), b}
+    return None
+
+@union_sets.register(Set, Set)
+def _(a, b):
+    return None

env-llmeval/lib/python3.10/site-packages/sympy/sets/ordinals.py

@@ -0,0 +1,282 @@
+from sympy.core import Basic, Integer
+import operator
+
+
+class OmegaPower(Basic):
+    """
+    Represents ordinal exponential and multiplication terms one of the
+    building blocks of the :class:`Ordinal` class.
+    In ``OmegaPower(a, b)``, ``a`` represents exponent and ``b`` represents multiplicity.
+    """
+    def __new__(cls, a, b):
+        if isinstance(b, int):
+            b = Integer(b)
+        if not isinstance(b, Integer) or b <= 0:
+            raise TypeError("multiplicity must be a positive integer")
+
+        if not isinstance(a, Ordinal):
+            a = Ordinal.convert(a)
+
+        return Basic.__new__(cls, a, b)
+
+    @property
+    def exp(self):
+        return self.args[0]
+
+    @property
+    def mult(self):
+        return self.args[1]
+
+    def _compare_term(self, other, op):
+        if self.exp == other.exp:
+            return op(self.mult, other.mult)
+        else:
+            return op(self.exp, other.exp)
+
+    def __eq__(self, other):
+        if not isinstance(other, OmegaPower):
+            try:
+                other = OmegaPower(0, other)
+            except TypeError:
+                return NotImplemented
+        return self.args == other.args
+
+    def __hash__(self):
+        return Basic.__hash__(self)
+
+    def __lt__(self, other):
+        if not isinstance(other, OmegaPower):
+            try:
+                other = OmegaPower(0, other)
+            except TypeError:
+                return NotImplemented
+        return self._compare_term(other, operator.lt)
+
+
+class Ordinal(Basic):
+    """
+    Represents ordinals in Cantor normal form.
+
+    Internally, this class is just a list of instances of OmegaPower.
+
+    Examples
+    ========
+    >>> from sympy import Ordinal, OmegaPower
+    >>> from sympy.sets.ordinals import omega
+    >>> w = omega
+    >>> w.is_limit_ordinal
+    True
+    >>> Ordinal(OmegaPower(w + 1, 1), OmegaPower(3, 2))
+    w**(w + 1) + w**3*2
+    >>> 3 + w
+    w
+    >>> (w + 1) * w
+    w**2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Ordinal_arithmetic
+    """
+    def __new__(cls, *terms):
+        obj = super().__new__(cls, *terms)
+        powers = [i.exp for i in obj.args]
+        if not all(powers[i] >= powers[i+1] for i in range(len(powers) - 1)):
+            raise ValueError("powers must be in decreasing order")
+        return obj
+
+    @property
+    def terms(self):
+        return self.args
+
+    @property
+    def leading_term(self):
+        if self == ord0:
+            raise ValueError("ordinal zero has no leading term")
+        return self.terms[0]
+
+    @property
+    def trailing_term(self):
+        if self == ord0:
+            raise ValueError("ordinal zero has no trailing term")
+        return self.terms[-1]
+
+    @property
+    def is_successor_ordinal(self):
+        try:
+            return self.trailing_term.exp == ord0
+        except ValueError:
+            return False
+
+    @property
+    def is_limit_ordinal(self):
+        try:
+            return not self.trailing_term.exp == ord0
+        except ValueError:
+            return False
+
+    @property
+    def degree(self):
+        return self.leading_term.exp
+
+    @classmethod
+    def convert(cls, integer_value):
+        if integer_value == 0:
+            return ord0
+        return Ordinal(OmegaPower(0, integer_value))
+
+    def __eq__(self, other):
+        if not isinstance(other, Ordinal):
+            try:
+                other = Ordinal.convert(other)
+            except TypeError:
+                return NotImplemented
+        return self.terms == other.terms
+
+    def __hash__(self):
+        return hash(self.args)
+
+    def __lt__(self, other):
+        if not isinstance(other, Ordinal):
+            try:
+                other = Ordinal.convert(other)
+            except TypeError:
+                return NotImplemented
+        for term_self, term_other in zip(self.terms, other.terms):
+            if term_self != term_other:
+                return term_self < term_other
+        return len(self.terms) < len(other.terms)
+
+    def __le__(self, other):
+        return (self == other or self < other)
+
+    def __gt__(self, other):
+        return not self <= other
+
+    def __ge__(self, other):
+        return not self < other
+
+    def __str__(self):
+        net_str = ""
+        plus_count = 0
+        if self == ord0:
+            return 'ord0'
+        for i in self.terms:
+            if plus_count:
+                net_str += " + "
+
+            if i.exp == ord0:
+                net_str += str(i.mult)
+            elif i.exp == 1:
+                net_str += 'w'
+            elif len(i.exp.terms) > 1 or i.exp.is_limit_ordinal:
+                net_str += 'w**(%s)'%i.exp
+            else:
+                net_str += 'w**%s'%i.exp
+
+            if not i.mult == 1 and not i.exp == ord0:
+                net_str += '*%s'%i.mult
+
+            plus_count += 1
+        return(net_str)
+
+    __repr__ = __str__
+
+    def __add__(self, other):
+        if not isinstance(other, Ordinal):
+            try:
+                other = Ordinal.convert(other)
+            except TypeError:
+                return NotImplemented
+        if other == ord0:
+            return self
+        a_terms = list(self.terms)
+        b_terms = list(other.terms)
+        r = len(a_terms) - 1
+        b_exp = other.degree
+        while r >= 0 and a_terms[r].exp < b_exp:
+            r -= 1
+        if r < 0:
+            terms = b_terms
+        elif a_terms[r].exp == b_exp:
+            sum_term = OmegaPower(b_exp, a_terms[r].mult + other.leading_term.mult)
+            terms = a_terms[:r] + [sum_term] + b_terms[1:]
+        else:
+            terms = a_terms[:r+1] + b_terms
+        return Ordinal(*terms)
+
+    def __radd__(self, other):
+        if not isinstance(other, Ordinal):
+            try:
+                other = Ordinal.convert(other)
+            except TypeError:
+                return NotImplemented
+        return other + self
+
+    def __mul__(self, other):
+        if not isinstance(other, Ordinal):
+            try:
+                other = Ordinal.convert(other)
+            except TypeError:
+                return NotImplemented
+        if ord0 in (self, other):
+            return ord0
+        a_exp = self.degree
+        a_mult = self.leading_term.mult
+        summation = []
+        if other.is_limit_ordinal:
+            for arg in other.terms:
+                summation.append(OmegaPower(a_exp + arg.exp, arg.mult))
+
+        else:
+            for arg in other.terms[:-1]:
+                summation.append(OmegaPower(a_exp + arg.exp, arg.mult))
+            b_mult = other.trailing_term.mult
+            summation.append(OmegaPower(a_exp, a_mult*b_mult))
+            summation += list(self.terms[1:])
+        return Ordinal(*summation)
+
+    def __rmul__(self, other):
+        if not isinstance(other, Ordinal):
+            try:
+                other = Ordinal.convert(other)
+            except TypeError:
+                return NotImplemented
+        return other * self
+
+    def __pow__(self, other):
+        if not self == omega:
+            return NotImplemented
+        return Ordinal(OmegaPower(other, 1))
+
+
+class OrdinalZero(Ordinal):
+    """The ordinal zero.
+
+    OrdinalZero can be imported as ``ord0``.
+    """
+    pass
+
+
+class OrdinalOmega(Ordinal):
+    """The ordinal omega which forms the base of all ordinals in cantor normal form.
+
+    OrdinalOmega can be imported as ``omega``.
+
+    Examples
+    ========
+
+    >>> from sympy.sets.ordinals import omega
+    >>> omega + omega
+    w*2
+    """
+    def __new__(cls):
+        return Ordinal.__new__(cls)
+
+    @property
+    def terms(self):
+        return (OmegaPower(1, 1),)
+
+
+ord0 = OrdinalZero()
+omega = OrdinalOmega()

env-llmeval/lib/python3.10/site-packages/sympy/sets/powerset.py

@@ -0,0 +1,119 @@
+from sympy.core.decorators import _sympifyit
+from sympy.core.parameters import global_parameters
+from sympy.core.logic import fuzzy_bool
+from sympy.core.singleton import S
+from sympy.core.sympify import _sympify
+
+from .sets import Set, FiniteSet, SetKind
+
+
+class PowerSet(Set):
+    r"""A symbolic object representing a power set.
+
+    Parameters
+    ==========
+
+    arg : Set
+        The set to take power of.
+
+    evaluate : bool
+        The flag to control evaluation.
+
+        If the evaluation is disabled for finite sets, it can take
+        advantage of using subset test as a membership test.
+
+    Notes
+    =====
+
+    Power set `\mathcal{P}(S)` is defined as a set containing all the
+    subsets of `S`.
+
+    If the set `S` is a finite set, its power set would have
+    `2^{\left| S \right|}` elements, where `\left| S \right|` denotes
+    the cardinality of `S`.
+
+    Examples
+    ========
+
+    >>> from sympy import PowerSet, S, FiniteSet
+
+    A power set of a finite set:
+
+    >>> PowerSet(FiniteSet(1, 2, 3))
+    PowerSet({1, 2, 3})
+
+    A power set of an empty set:
+
+    >>> PowerSet(S.EmptySet)
+    PowerSet(EmptySet)
+    >>> PowerSet(PowerSet(S.EmptySet))
+    PowerSet(PowerSet(EmptySet))
+
+    A power set of an infinite set:
+
+    >>> PowerSet(S.Reals)
+    PowerSet(Reals)
+
+    Evaluating the power set of a finite set to its explicit form:
+
+    >>> PowerSet(FiniteSet(1, 2, 3)).rewrite(FiniteSet)
+    FiniteSet(EmptySet, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3})
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Power_set
+
+    .. [2] https://en.wikipedia.org/wiki/Axiom_of_power_set
+    """
+    def __new__(cls, arg, evaluate=None):
+        if evaluate is None:
+            evaluate=global_parameters.evaluate
+
+        arg = _sympify(arg)
+
+        if not isinstance(arg, Set):
+            raise ValueError('{} must be a set.'.format(arg))
+
+        return super().__new__(cls, arg)
+
+    @property
+    def arg(self):
+        return self.args[0]
+
+    def _eval_rewrite_as_FiniteSet(self, *args, **kwargs):
+        arg = self.arg
+        if arg.is_FiniteSet:
+            return arg.powerset()
+        return None
+
+    @_sympifyit('other', NotImplemented)
+    def _contains(self, other):
+        if not isinstance(other, Set):
+            return None
+
+        return fuzzy_bool(self.arg.is_superset(other))
+
+    def _eval_is_subset(self, other):
+        if isinstance(other, PowerSet):
+            return self.arg.is_subset(other.arg)
+
+    def __len__(self):
+        return 2 ** len(self.arg)
+
+    def __iter__(self):
+        found = [S.EmptySet]
+        yield S.EmptySet
+
+        for x in self.arg:
+            temp = []
+            x = FiniteSet(x)
+            for y in found:
+                new = x + y
+                yield new
+                temp.append(new)
+            found.extend(temp)
+
+    @property
+    def kind(self):
+        return SetKind(self.arg.kind)

env-llmeval/lib/python3.10/site-packages/sympy/sets/setexpr.py

@@ -0,0 +1,97 @@
+from sympy.core import Expr
+from sympy.core.decorators import call_highest_priority, _sympifyit
+from .fancysets import ImageSet
+from .sets import set_add, set_sub, set_mul, set_div, set_pow, set_function
+
+
+class SetExpr(Expr):
+    """An expression that can take on values of a set.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, FiniteSet
+    >>> from sympy.sets.setexpr import SetExpr
+
+    >>> a = SetExpr(Interval(0, 5))
+    >>> b = SetExpr(FiniteSet(1, 10))
+    >>> (a + b).set
+    Union(Interval(1, 6), Interval(10, 15))
+    >>> (2*a + b).set
+    Interval(1, 20)
+    """
+    _op_priority = 11.0
+
+    def __new__(cls, setarg):
+        return Expr.__new__(cls, setarg)
+
+    set = property(lambda self: self.args[0])
+
+    def _latex(self, printer):
+        return r"SetExpr\left({}\right)".format(printer._print(self.set))
+
+    @_sympifyit('other', NotImplemented)
+    @call_highest_priority('__radd__')
+    def __add__(self, other):
+        return _setexpr_apply_operation(set_add, self, other)
+
+    @_sympifyit('other', NotImplemented)
+    @call_highest_priority('__add__')
+    def __radd__(self, other):
+        return _setexpr_apply_operation(set_add, other, self)
+
+    @_sympifyit('other', NotImplemented)
+    @call_highest_priority('__rmul__')
+    def __mul__(self, other):
+        return _setexpr_apply_operation(set_mul, self, other)
+
+    @_sympifyit('other', NotImplemented)
+    @call_highest_priority('__mul__')
+    def __rmul__(self, other):
+        return _setexpr_apply_operation(set_mul, other, self)
+
+    @_sympifyit('other', NotImplemented)
+    @call_highest_priority('__rsub__')
+    def __sub__(self, other):
+        return _setexpr_apply_operation(set_sub, self, other)
+
+    @_sympifyit('other', NotImplemented)
+    @call_highest_priority('__sub__')
+    def __rsub__(self, other):
+        return _setexpr_apply_operation(set_sub, other, self)
+
+    @_sympifyit('other', NotImplemented)
+    @call_highest_priority('__rpow__')
+    def __pow__(self, other):
+        return _setexpr_apply_operation(set_pow, self, other)
+
+    @_sympifyit('other', NotImplemented)
+    @call_highest_priority('__pow__')
+    def __rpow__(self, other):
+        return _setexpr_apply_operation(set_pow, other, self)
+
+    @_sympifyit('other', NotImplemented)
+    @call_highest_priority('__rtruediv__')
+    def __truediv__(self, other):
+        return _setexpr_apply_operation(set_div, self, other)
+
+    @_sympifyit('other', NotImplemented)
+    @call_highest_priority('__truediv__')
+    def __rtruediv__(self, other):
+        return _setexpr_apply_operation(set_div, other, self)
+
+    def _eval_func(self, func):
+        # TODO: this could be implemented straight into `imageset`:
+        res = set_function(func, self.set)
+        if res is None:
+            return SetExpr(ImageSet(func, self.set))
+        return SetExpr(res)
+
+
+def _setexpr_apply_operation(op, x, y):
+    if isinstance(x, SetExpr):
+        x = x.set
+    if isinstance(y, SetExpr):
+        y = y.set
+    out = op(x, y)
+    return SetExpr(out)

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

@@ -0,0 +1,2749 @@
+from typing import Any, Callable
+from functools import reduce
+from collections import defaultdict
+import inspect
+
+from sympy.core.kind import Kind, UndefinedKind, NumberKind
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple, TupleKind
+from sympy.core.decorators import sympify_method_args, sympify_return
+from sympy.core.evalf import EvalfMixin
+from sympy.core.expr import Expr
+from sympy.core.function import Lambda
+from sympy.core.logic import (FuzzyBool, fuzzy_bool, fuzzy_or, fuzzy_and,
+    fuzzy_not)
+from sympy.core.numbers import Float, Integer
+from sympy.core.operations import LatticeOp
+from sympy.core.parameters import global_parameters
+from sympy.core.relational import Eq, Ne, is_lt
+from sympy.core.singleton import Singleton, S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import symbols, Symbol, Dummy, uniquely_named_symbol
+from sympy.core.sympify import _sympify, sympify, _sympy_converter
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.miscellaneous import Max, Min
+from sympy.logic.boolalg import And, Or, Not, Xor, true, false
+from sympy.utilities.decorator import deprecated
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import (iproduct, sift, roundrobin, iterable,
+                                       subsets)
+from sympy.utilities.misc import func_name, filldedent
+
+from mpmath import mpi, mpf
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+tfn = defaultdict(lambda: None, {
+    True: S.true,
+    S.true: S.true,
+    False: S.false,
+    S.false: S.false})
+
+
+@sympify_method_args
+class Set(Basic, EvalfMixin):
+    """
+    The base class for any kind of set.
+
+    Explanation
+    ===========
+
+    This is not meant to be used directly as a container of items. It does not
+    behave like the builtin ``set``; see :class:`FiniteSet` for that.
+
+    Real intervals are represented by the :class:`Interval` class and unions of
+    sets by the :class:`Union` class. The empty set is represented by the
+    :class:`EmptySet` class and available as a singleton as ``S.EmptySet``.
+    """
+
+    __slots__ = ()
+
+    is_number = False
+    is_iterable = False
+    is_interval = False
+
+    is_FiniteSet = False
+    is_Interval = False
+    is_ProductSet = False
+    is_Union = False
+    is_Intersection: FuzzyBool = None
+    is_UniversalSet: FuzzyBool = None
+    is_Complement: FuzzyBool = None
+    is_ComplexRegion = False
+
+    is_empty: FuzzyBool = None
+    is_finite_set: FuzzyBool = None
+
+    @property  # type: ignore
+    @deprecated(
+        """
+        The is_EmptySet attribute of Set objects is deprecated.
+        Use 's is S.EmptySet" or 's.is_empty' instead.
+        """,
+        deprecated_since_version="1.5",
+        active_deprecations_target="deprecated-is-emptyset",
+    )
+    def is_EmptySet(self):
+        return None
+
+    @staticmethod
+    def _infimum_key(expr):
+        """
+        Return infimum (if possible) else S.Infinity.
+        """
+        try:
+            infimum = expr.inf
+            assert infimum.is_comparable
+            infimum = infimum.evalf()  # issue #18505
+        except (NotImplementedError,
+                AttributeError, AssertionError, ValueError):
+            infimum = S.Infinity
+        return infimum
+
+    def union(self, other):
+        """
+        Returns the union of ``self`` and ``other``.
+
+        Examples
+        ========
+
+        As a shortcut it is possible to use the ``+`` operator:
+
+        >>> from sympy import Interval, FiniteSet
+        >>> Interval(0, 1).union(Interval(2, 3))
+        Union(Interval(0, 1), Interval(2, 3))
+        >>> Interval(0, 1) + Interval(2, 3)
+        Union(Interval(0, 1), Interval(2, 3))
+        >>> Interval(1, 2, True, True) + FiniteSet(2, 3)
+        Union({3}, Interval.Lopen(1, 2))
+
+        Similarly it is possible to use the ``-`` operator for set differences:
+
+        >>> Interval(0, 2) - Interval(0, 1)
+        Interval.Lopen(1, 2)
+        >>> Interval(1, 3) - FiniteSet(2)
+        Union(Interval.Ropen(1, 2), Interval.Lopen(2, 3))
+
+        """
+        return Union(self, other)
+
+    def intersect(self, other):
+        """
+        Returns the intersection of 'self' and 'other'.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval
+
+        >>> Interval(1, 3).intersect(Interval(1, 2))
+        Interval(1, 2)
+
+        >>> from sympy import imageset, Lambda, symbols, S
+        >>> n, m = symbols('n m')
+        >>> a = imageset(Lambda(n, 2*n), S.Integers)
+        >>> a.intersect(imageset(Lambda(m, 2*m + 1), S.Integers))
+        EmptySet
+
+        """
+        return Intersection(self, other)
+
+    def intersection(self, other):
+        """
+        Alias for :meth:`intersect()`
+        """
+        return self.intersect(other)
+
+    def is_disjoint(self, other):
+        """
+        Returns True if ``self`` and ``other`` are disjoint.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval
+        >>> Interval(0, 2).is_disjoint(Interval(1, 2))
+        False
+        >>> Interval(0, 2).is_disjoint(Interval(3, 4))
+        True
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Disjoint_sets
+        """
+        return self.intersect(other) == S.EmptySet
+
+    def isdisjoint(self, other):
+        """
+        Alias for :meth:`is_disjoint()`
+        """
+        return self.is_disjoint(other)
+
+    def complement(self, universe):
+        r"""
+        The complement of 'self' w.r.t the given universe.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, S
+        >>> Interval(0, 1).complement(S.Reals)
+        Union(Interval.open(-oo, 0), Interval.open(1, oo))
+
+        >>> Interval(0, 1).complement(S.UniversalSet)
+        Complement(UniversalSet, Interval(0, 1))
+
+        """
+        return Complement(universe, self)
+
+    def _complement(self, other):
+        # this behaves as other - self
+        if isinstance(self, ProductSet) and isinstance(other, ProductSet):
+            # If self and other are disjoint then other - self == self
+            if len(self.sets) != len(other.sets):
+                return other
+
+            # There can be other ways to represent this but this gives:
+            # (A x B) - (C x D) = ((A - C) x B) U (A x (B - D))
+            overlaps = []
+            pairs = list(zip(self.sets, other.sets))
+            for n in range(len(pairs)):
+                sets = (o if i != n else o-s for i, (s, o) in enumerate(pairs))
+                overlaps.append(ProductSet(*sets))
+            return Union(*overlaps)
+
+        elif isinstance(other, Interval):
+            if isinstance(self, (Interval, FiniteSet)):
+                return Intersection(other, self.complement(S.Reals))
+
+        elif isinstance(other, Union):
+            return Union(*(o - self for o in other.args))
+
+        elif isinstance(other, Complement):
+            return Complement(other.args[0], Union(other.args[1], self), evaluate=False)
+
+        elif other is S.EmptySet:
+            return S.EmptySet
+
+        elif isinstance(other, FiniteSet):
+            sifted = sift(other, lambda x: fuzzy_bool(self.contains(x)))
+            # ignore those that are contained in self
+            return Union(FiniteSet(*(sifted[False])),
+                Complement(FiniteSet(*(sifted[None])), self, evaluate=False)
+                if sifted[None] else S.EmptySet)
+
+    def symmetric_difference(self, other):
+        """
+        Returns symmetric difference of ``self`` and ``other``.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, S
+        >>> Interval(1, 3).symmetric_difference(S.Reals)
+        Union(Interval.open(-oo, 1), Interval.open(3, oo))
+        >>> Interval(1, 10).symmetric_difference(S.Reals)
+        Union(Interval.open(-oo, 1), Interval.open(10, oo))
+
+        >>> from sympy import S, EmptySet
+        >>> S.Reals.symmetric_difference(EmptySet)
+        Reals
+
+        References
+        ==========
+        .. [1] https://en.wikipedia.org/wiki/Symmetric_difference
+
+        """
+        return SymmetricDifference(self, other)
+
+    def _symmetric_difference(self, other):
+        return Union(Complement(self, other), Complement(other, self))
+
+    @property
+    def inf(self):
+        """
+        The infimum of ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, Union
+        >>> Interval(0, 1).inf
+        0
+        >>> Union(Interval(0, 1), Interval(2, 3)).inf
+        0
+
+        """
+        return self._inf
+
+    @property
+    def _inf(self):
+        raise NotImplementedError("(%s)._inf" % self)
+
+    @property
+    def sup(self):
+        """
+        The supremum of ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, Union
+        >>> Interval(0, 1).sup
+        1
+        >>> Union(Interval(0, 1), Interval(2, 3)).sup
+        3
+
+        """
+        return self._sup
+
+    @property
+    def _sup(self):
+        raise NotImplementedError("(%s)._sup" % self)
+
+    def contains(self, other):
+        """
+        Returns a SymPy value indicating whether ``other`` is contained
+        in ``self``: ``true`` if it is, ``false`` if it is not, else
+        an unevaluated ``Contains`` expression (or, as in the case of
+        ConditionSet and a union of FiniteSet/Intervals, an expression
+        indicating the conditions for containment).
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, S
+        >>> from sympy.abc import x
+
+        >>> Interval(0, 1).contains(0.5)
+        True
+
+        As a shortcut it is possible to use the ``in`` operator, but that
+        will raise an error unless an affirmative true or false is not
+        obtained.
+
+        >>> Interval(0, 1).contains(x)
+        (0 <= x) & (x <= 1)
+        >>> x in Interval(0, 1)
+        Traceback (most recent call last):
+        ...
+        TypeError: did not evaluate to a bool: None
+
+        The result of 'in' is a bool, not a SymPy value
+
+        >>> 1 in Interval(0, 2)
+        True
+        >>> _ is S.true
+        False
+        """
+        from .contains import Contains
+        other = sympify(other, strict=True)
+
+        c = self._contains(other)
+        if isinstance(c, Contains):
+            return c
+        if c is None:
+            return Contains(other, self, evaluate=False)
+        b = tfn[c]
+        if b is None:
+            return c
+        return b
+
+    def _contains(self, other):
+        raise NotImplementedError(filldedent('''
+            (%s)._contains(%s) is not defined. This method, when
+            defined, will receive a sympified object. The method
+            should return True, False, None or something that
+            expresses what must be true for the containment of that
+            object in self to be evaluated. If None is returned
+            then a generic Contains object will be returned
+            by the ``contains`` method.''' % (self, other)))
+
+    def is_subset(self, other):
+        """
+        Returns True if ``self`` is a subset of ``other``.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval
+        >>> Interval(0, 0.5).is_subset(Interval(0, 1))
+        True
+        >>> Interval(0, 1).is_subset(Interval(0, 1, left_open=True))
+        False
+
+        """
+        if not isinstance(other, Set):
+            raise ValueError("Unknown argument '%s'" % other)
+
+        # Handle the trivial cases
+        if self == other:
+            return True
+        is_empty = self.is_empty
+        if is_empty is True:
+            return True
+        elif fuzzy_not(is_empty) and other.is_empty:
+            return False
+        if self.is_finite_set is False and other.is_finite_set:
+            return False
+
+        # Dispatch on subclass rules
+        ret = self._eval_is_subset(other)
+        if ret is not None:
+            return ret
+        ret = other._eval_is_superset(self)
+        if ret is not None:
+            return ret
+
+        # Use pairwise rules from multiple dispatch
+        from sympy.sets.handlers.issubset import is_subset_sets
+        ret = is_subset_sets(self, other)
+        if ret is not None:
+            return ret
+
+        # Fall back on computing the intersection
+        # XXX: We shouldn't do this. A query like this should be handled
+        # without evaluating new Set objects. It should be the other way round
+        # so that the intersect method uses is_subset for evaluation.
+        if self.intersect(other) == self:
+            return True
+
+    def _eval_is_subset(self, other):
+        '''Returns a fuzzy bool for whether self is a subset of other.'''
+        return None
+
+    def _eval_is_superset(self, other):
+        '''Returns a fuzzy bool for whether self is a subset of other.'''
+        return None
+
+    # This should be deprecated:
+    def issubset(self, other):
+        """
+        Alias for :meth:`is_subset()`
+        """
+        return self.is_subset(other)
+
+    def is_proper_subset(self, other):
+        """
+        Returns True if ``self`` is a proper subset of ``other``.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval
+        >>> Interval(0, 0.5).is_proper_subset(Interval(0, 1))
+        True
+        >>> Interval(0, 1).is_proper_subset(Interval(0, 1))
+        False
+
+        """
+        if isinstance(other, Set):
+            return self != other and self.is_subset(other)
+        else:
+            raise ValueError("Unknown argument '%s'" % other)
+
+    def is_superset(self, other):
+        """
+        Returns True if ``self`` is a superset of ``other``.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval
+        >>> Interval(0, 0.5).is_superset(Interval(0, 1))
+        False
+        >>> Interval(0, 1).is_superset(Interval(0, 1, left_open=True))
+        True
+
+        """
+        if isinstance(other, Set):
+            return other.is_subset(self)
+        else:
+            raise ValueError("Unknown argument '%s'" % other)
+
+    # This should be deprecated:
+    def issuperset(self, other):
+        """
+        Alias for :meth:`is_superset()`
+        """
+        return self.is_superset(other)
+
+    def is_proper_superset(self, other):
+        """
+        Returns True if ``self`` is a proper superset of ``other``.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval
+        >>> Interval(0, 1).is_proper_superset(Interval(0, 0.5))
+        True
+        >>> Interval(0, 1).is_proper_superset(Interval(0, 1))
+        False
+
+        """
+        if isinstance(other, Set):
+            return self != other and self.is_superset(other)
+        else:
+            raise ValueError("Unknown argument '%s'" % other)
+
+    def _eval_powerset(self):
+        from .powerset import PowerSet
+        return PowerSet(self)
+
+    def powerset(self):
+        """
+        Find the Power set of ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy import EmptySet, FiniteSet, Interval
+
+        A power set of an empty set:
+
+        >>> A = EmptySet
+        >>> A.powerset()
+        {EmptySet}
+
+        A power set of a finite set:
+
+        >>> A = FiniteSet(1, 2)
+        >>> a, b, c = FiniteSet(1), FiniteSet(2), FiniteSet(1, 2)
+        >>> A.powerset() == FiniteSet(a, b, c, EmptySet)
+        True
+
+        A power set of an interval:
+
+        >>> Interval(1, 2).powerset()
+        PowerSet(Interval(1, 2))
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Power_set
+
+        """
+        return self._eval_powerset()
+
+    @property
+    def measure(self):
+        """
+        The (Lebesgue) measure of ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, Union
+        >>> Interval(0, 1).measure
+        1
+        >>> Union(Interval(0, 1), Interval(2, 3)).measure
+        2
+
+        """
+        return self._measure
+
+    @property
+    def kind(self):
+        """
+        The kind of a Set
+
+        Explanation
+        ===========
+
+        Any :class:`Set` will have kind :class:`SetKind` which is
+        parametrised by the kind of the elements of the set. For example
+        most sets are sets of numbers and will have kind
+        ``SetKind(NumberKind)``. If elements of sets are different in kind than
+        their kind will ``SetKind(UndefinedKind)``. See
+        :class:`sympy.core.kind.Kind` for an explanation of the kind system.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, Matrix, FiniteSet, EmptySet, ProductSet, PowerSet
+
+        >>> FiniteSet(Matrix([1, 2])).kind
+        SetKind(MatrixKind(NumberKind))
+
+        >>> Interval(1, 2).kind
+        SetKind(NumberKind)
+
+        >>> EmptySet.kind
+        SetKind()
+
+        A :class:`sympy.sets.powerset.PowerSet` is a set of sets:
+
+        >>> PowerSet({1, 2, 3}).kind
+        SetKind(SetKind(NumberKind))
+
+        A :class:`ProductSet` represents the set of tuples of elements of
+        other sets. Its kind is :class:`sympy.core.containers.TupleKind`
+        parametrised by the kinds of the elements of those sets:
+
+        >>> p = ProductSet(FiniteSet(1, 2), FiniteSet(3, 4))
+        >>> list(p)
+        [(1, 3), (2, 3), (1, 4), (2, 4)]
+        >>> p.kind
+        SetKind(TupleKind(NumberKind, NumberKind))
+
+        When all elements of the set do not have same kind, the kind
+        will be returned as ``SetKind(UndefinedKind)``:
+
+        >>> FiniteSet(0, Matrix([1, 2])).kind
+        SetKind(UndefinedKind)
+
+        The kind of the elements of a set are given by the ``element_kind``
+        attribute of ``SetKind``:
+
+        >>> Interval(1, 2).kind.element_kind
+        NumberKind
+
+        See Also
+        ========
+
+        NumberKind
+        sympy.core.kind.UndefinedKind
+        sympy.core.containers.TupleKind
+        MatrixKind
+        sympy.matrices.expressions.sets.MatrixSet
+        sympy.sets.conditionset.ConditionSet
+        Rationals
+        Naturals
+        Integers
+        sympy.sets.fancysets.ImageSet
+        sympy.sets.fancysets.Range
+        sympy.sets.fancysets.ComplexRegion
+        sympy.sets.powerset.PowerSet
+        sympy.sets.sets.ProductSet
+        sympy.sets.sets.Interval
+        sympy.sets.sets.Union
+        sympy.sets.sets.Intersection
+        sympy.sets.sets.Complement
+        sympy.sets.sets.EmptySet
+        sympy.sets.sets.UniversalSet
+        sympy.sets.sets.FiniteSet
+        sympy.sets.sets.SymmetricDifference
+        sympy.sets.sets.DisjointUnion
+        """
+        return self._kind()
+
+    @property
+    def boundary(self):
+        """
+        The boundary or frontier of a set.
+
+        Explanation
+        ===========
+
+        A point x is on the boundary of a set S if
+
+        1.  x is in the closure of S.
+            I.e. Every neighborhood of x contains a point in S.
+        2.  x is not in the interior of S.
+            I.e. There does not exist an open set centered on x contained
+            entirely within S.
+
+        There are the points on the outer rim of S.  If S is open then these
+        points need not actually be contained within S.
+
+        For example, the boundary of an interval is its start and end points.
+        This is true regardless of whether or not the interval is open.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval
+        >>> Interval(0, 1).boundary
+        {0, 1}
+        >>> Interval(0, 1, True, False).boundary
+        {0, 1}
+        """
+        return self._boundary
+
+    @property
+    def is_open(self):
+        """
+        Property method to check whether a set is open.
+
+        Explanation
+        ===========
+
+        A set is open if and only if it has an empty intersection with its
+        boundary. In particular, a subset A of the reals is open if and only
+        if each one of its points is contained in an open interval that is a
+        subset of A.
+
+        Examples
+        ========
+        >>> from sympy import S
+        >>> S.Reals.is_open
+        True
+        >>> S.Rationals.is_open
+        False
+        """
+        return Intersection(self, self.boundary).is_empty
+
+    @property
+    def is_closed(self):
+        """
+        A property method to check whether a set is closed.
+
+        Explanation
+        ===========
+
+        A set is closed if its complement is an open set. The closedness of a
+        subset of the reals is determined with respect to R and its standard
+        topology.
+
+        Examples
+        ========
+        >>> from sympy import Interval
+        >>> Interval(0, 1).is_closed
+        True
+        """
+        return self.boundary.is_subset(self)
+
+    @property
+    def closure(self):
+        """
+        Property method which returns the closure of a set.
+        The closure is defined as the union of the set itself and its
+        boundary.
+
+        Examples
+        ========
+        >>> from sympy import S, Interval
+        >>> S.Reals.closure
+        Reals
+        >>> Interval(0, 1).closure
+        Interval(0, 1)
+        """
+        return self + self.boundary
+
+    @property
+    def interior(self):
+        """
+        Property method which returns the interior of a set.
+        The interior of a set S consists all points of S that do not
+        belong to the boundary of S.
+
+        Examples
+        ========
+        >>> from sympy import Interval
+        >>> Interval(0, 1).interior
+        Interval.open(0, 1)
+        >>> Interval(0, 1).boundary.interior
+        EmptySet
+        """
+        return self - self.boundary
+
+    @property
+    def _boundary(self):
+        raise NotImplementedError()
+
+    @property
+    def _measure(self):
+        raise NotImplementedError("(%s)._measure" % self)
+
+    def _kind(self):
+        return SetKind(UndefinedKind)
+
+    def _eval_evalf(self, prec):
+        dps = prec_to_dps(prec)
+        return self.func(*[arg.evalf(n=dps) for arg in self.args])
+
+    @sympify_return([('other', 'Set')], NotImplemented)
+    def __add__(self, other):
+        return self.union(other)
+
+    @sympify_return([('other', 'Set')], NotImplemented)
+    def __or__(self, other):
+        return self.union(other)
+
+    @sympify_return([('other', 'Set')], NotImplemented)
+    def __and__(self, other):
+        return self.intersect(other)
+
+    @sympify_return([('other', 'Set')], NotImplemented)
+    def __mul__(self, other):
+        return ProductSet(self, other)
+
+    @sympify_return([('other', 'Set')], NotImplemented)
+    def __xor__(self, other):
+        return SymmetricDifference(self, other)
+
+    @sympify_return([('exp', Expr)], NotImplemented)
+    def __pow__(self, exp):
+        if not (exp.is_Integer and exp >= 0):
+            raise ValueError("%s: Exponent must be a positive Integer" % exp)
+        return ProductSet(*[self]*exp)
+
+    @sympify_return([('other', 'Set')], NotImplemented)
+    def __sub__(self, other):
+        return Complement(self, other)
+
+    def __contains__(self, other):
+        other = _sympify(other)
+        c = self._contains(other)
+        b = tfn[c]
+        if b is None:
+            # x in y must evaluate to T or F; to entertain a None
+            # result with Set use y.contains(x)
+            raise TypeError('did not evaluate to a bool: %r' % c)
+        return b
+
+
+class ProductSet(Set):
+    """
+    Represents a Cartesian Product of Sets.
+
+    Explanation
+    ===========
+
+    Returns a Cartesian product given several sets as either an iterable
+    or individual arguments.
+
+    Can use ``*`` operator on any sets for convenient shorthand.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, FiniteSet, ProductSet
+    >>> I = Interval(0, 5); S = FiniteSet(1, 2, 3)
+    >>> ProductSet(I, S)
+    ProductSet(Interval(0, 5), {1, 2, 3})
+
+    >>> (2, 2) in ProductSet(I, S)
+    True
+
+    >>> Interval(0, 1) * Interval(0, 1) # The unit square
+    ProductSet(Interval(0, 1), Interval(0, 1))
+
+    >>> coin = FiniteSet('H', 'T')
+    >>> set(coin**2)
+    {(H, H), (H, T), (T, H), (T, T)}
+
+    The Cartesian product is not commutative or associative e.g.:
+
+    >>> I*S == S*I
+    False
+    >>> (I*I)*I == I*(I*I)
+    False
+
+    Notes
+    =====
+
+    - Passes most operations down to the argument sets
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Cartesian_product
+    """
+    is_ProductSet = True
+
+    def __new__(cls, *sets, **assumptions):
+        if len(sets) == 1 and iterable(sets[0]) and not isinstance(sets[0], (Set, set)):
+            sympy_deprecation_warning(
+                """
+ProductSet(iterable) is deprecated. Use ProductSet(*iterable) instead.
+                """,
+                deprecated_since_version="1.5",
+                active_deprecations_target="deprecated-productset-iterable",
+            )
+            sets = tuple(sets[0])
+
+        sets = [sympify(s) for s in sets]
+
+        if not all(isinstance(s, Set) for s in sets):
+            raise TypeError("Arguments to ProductSet should be of type Set")
+
+        # Nullary product of sets is *not* the empty set
+        if len(sets) == 0:
+            return FiniteSet(())
+
+        if S.EmptySet in sets:
+            return S.EmptySet
+
+        return Basic.__new__(cls, *sets, **assumptions)
+
+    @property
+    def sets(self):
+        return self.args
+
+    def flatten(self):
+        def _flatten(sets):
+            for s in sets:
+                if s.is_ProductSet:
+                    yield from _flatten(s.sets)
+                else:
+                    yield s
+        return ProductSet(*_flatten(self.sets))
+
+
+
+    def _contains(self, element):
+        """
+        ``in`` operator for ProductSets.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval
+        >>> (2, 3) in Interval(0, 5) * Interval(0, 5)
+        True
+
+        >>> (10, 10) in Interval(0, 5) * Interval(0, 5)
+        False
+
+        Passes operation on to constituent sets
+        """
+        if element.is_Symbol:
+            return None
+
+        if not isinstance(element, Tuple) or len(element) != len(self.sets):
+            return False
+
+        return fuzzy_and(s._contains(e) for s, e in zip(self.sets, element))
+
+    def as_relational(self, *symbols):
+        symbols = [_sympify(s) for s in symbols]
+        if len(symbols) != len(self.sets) or not all(
+                i.is_Symbol for i in symbols):
+            raise ValueError(
+                'number of symbols must match the number of sets')
+        return And(*[s.as_relational(i) for s, i in zip(self.sets, symbols)])
+
+    @property
+    def _boundary(self):
+        return Union(*(ProductSet(*(b + b.boundary if i != j else b.boundary
+                                for j, b in enumerate(self.sets)))
+                                for i, a in enumerate(self.sets)))
+
+    @property
+    def is_iterable(self):
+        """
+        A property method which tests whether a set is iterable or not.
+        Returns True if set is iterable, otherwise returns False.
+
+        Examples
+        ========
+
+        >>> from sympy import FiniteSet, Interval
+        >>> I = Interval(0, 1)
+        >>> A = FiniteSet(1, 2, 3, 4, 5)
+        >>> I.is_iterable
+        False
+        >>> A.is_iterable
+        True
+
+        """
+        return all(set.is_iterable for set in self.sets)
+
+    def __iter__(self):
+        """
+        A method which implements is_iterable property method.
+        If self.is_iterable returns True (both constituent sets are iterable),
+        then return the Cartesian Product. Otherwise, raise TypeError.
+        """
+        return iproduct(*self.sets)
+
+    @property
+    def is_empty(self):
+        return fuzzy_or(s.is_empty for s in self.sets)
+
+    @property
+    def is_finite_set(self):
+        all_finite = fuzzy_and(s.is_finite_set for s in self.sets)
+        return fuzzy_or([self.is_empty, all_finite])
+
+    @property
+    def _measure(self):
+        measure = 1
+        for s in self.sets:
+            measure *= s.measure
+        return measure
+
+    def _kind(self):
+        return SetKind(TupleKind(*(i.kind.element_kind for i in self.args)))
+
+    def __len__(self):
+        return reduce(lambda a, b: a*b, (len(s) for s in self.args))
+
+    def __bool__(self):
+        return all(self.sets)
+
+
+class Interval(Set):
+    """
+    Represents a real interval as a Set.
+
+    Usage:
+        Returns an interval with end points ``start`` and ``end``.
+
+        For ``left_open=True`` (default ``left_open`` is ``False``) the interval
+        will be open on the left. Similarly, for ``right_open=True`` the interval
+        will be open on the right.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, Interval
+    >>> Interval(0, 1)
+    Interval(0, 1)
+    >>> Interval.Ropen(0, 1)
+    Interval.Ropen(0, 1)
+    >>> Interval.Ropen(0, 1)
+    Interval.Ropen(0, 1)
+    >>> Interval.Lopen(0, 1)
+    Interval.Lopen(0, 1)
+    >>> Interval.open(0, 1)
+    Interval.open(0, 1)
+
+    >>> a = Symbol('a', real=True)
+    >>> Interval(0, a)
+    Interval(0, a)
+
+    Notes
+    =====
+    - Only real end points are supported
+    - ``Interval(a, b)`` with $a > b$ will return the empty set
+    - Use the ``evalf()`` method to turn an Interval into an mpmath
+      ``mpi`` interval instance
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Interval_%28mathematics%29
+    """
+    is_Interval = True
+
+    def __new__(cls, start, end, left_open=False, right_open=False):
+
+        start = _sympify(start)
+        end = _sympify(end)
+        left_open = _sympify(left_open)
+        right_open = _sympify(right_open)
+
+        if not all(isinstance(a, (type(true), type(false)))
+            for a in [left_open, right_open]):
+            raise NotImplementedError(
+                "left_open and right_open can have only true/false values, "
+                "got %s and %s" % (left_open, right_open))
+
+        # Only allow real intervals
+        if fuzzy_not(fuzzy_and(i.is_extended_real for i in (start, end, end-start))):
+            raise ValueError("Non-real intervals are not supported")
+
+        # evaluate if possible
+        if is_lt(end, start):
+            return S.EmptySet
+        elif (end - start).is_negative:
+            return S.EmptySet
+
+        if end == start and (left_open or right_open):
+            return S.EmptySet
+        if end == start and not (left_open or right_open):
+            if start is S.Infinity or start is S.NegativeInfinity:
+                return S.EmptySet
+            return FiniteSet(end)
+
+        # Make sure infinite interval end points are open.
+        if start is S.NegativeInfinity:
+            left_open = true
+        if end is S.Infinity:
+            right_open = true
+        if start == S.Infinity or end == S.NegativeInfinity:
+            return S.EmptySet
+
+        return Basic.__new__(cls, start, end, left_open, right_open)
+
+    @property
+    def start(self):
+        """
+        The left end point of the interval.
+
+        This property takes the same value as the ``inf`` property.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval
+        >>> Interval(0, 1).start
+        0
+
+        """
+        return self._args[0]
+
+    @property
+    def end(self):
+        """
+        The right end point of the interval.
+
+        This property takes the same value as the ``sup`` property.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval
+        >>> Interval(0, 1).end
+        1
+
+        """
+        return self._args[1]
+
+    @property
+    def left_open(self):
+        """
+        True if interval is left-open.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval
+        >>> Interval(0, 1, left_open=True).left_open
+        True
+        >>> Interval(0, 1, left_open=False).left_open
+        False
+
+        """
+        return self._args[2]
+
+    @property
+    def right_open(self):
+        """
+        True if interval is right-open.
+
+        Examples
+        ========
+
+        >>> from sympy import Interval
+        >>> Interval(0, 1, right_open=True).right_open
+        True
+        >>> Interval(0, 1, right_open=False).right_open
+        False
+
+        """
+        return self._args[3]
+
+    @classmethod
+    def open(cls, a, b):
+        """Return an interval including neither boundary."""
+        return cls(a, b, True, True)
+
+    @classmethod
+    def Lopen(cls, a, b):
+        """Return an interval not including the left boundary."""
+        return cls(a, b, True, False)
+
+    @classmethod
+    def Ropen(cls, a, b):
+        """Return an interval not including the right boundary."""
+        return cls(a, b, False, True)
+
+    @property
+    def _inf(self):
+        return self.start
+
+    @property
+    def _sup(self):
+        return self.end
+
+    @property
+    def left(self):
+        return self.start
+
+    @property
+    def right(self):
+        return self.end
+
+    @property
+    def is_empty(self):
+        if self.left_open or self.right_open:
+            cond = self.start >= self.end  # One/both bounds open
+        else:
+            cond = self.start > self.end  # Both bounds closed
+        return fuzzy_bool(cond)
+
+    @property
+    def is_finite_set(self):
+        return self.measure.is_zero
+
+    def _complement(self, other):
+        if other == S.Reals:
+            a = Interval(S.NegativeInfinity, self.start,
+                         True, not self.left_open)
+            b = Interval(self.end, S.Infinity, not self.right_open, True)
+            return Union(a, b)
+
+        if isinstance(other, FiniteSet):
+            nums = [m for m in other.args if m.is_number]
+            if nums == []:
+                return None
+
+        return Set._complement(self, other)
+
+    @property
+    def _boundary(self):
+        finite_points = [p for p in (self.start, self.end)
+                         if abs(p) != S.Infinity]
+        return FiniteSet(*finite_points)
+
+    def _contains(self, other):
+        if (not isinstance(other, Expr) or other is S.NaN
+            or other.is_real is False or other.has(S.ComplexInfinity)):
+                # if an expression has zoo it will be zoo or nan
+                # and neither of those is real
+                return false
+
+        if self.start is S.NegativeInfinity and self.end is S.Infinity:
+            if other.is_real is not None:
+                return other.is_real
+
+        d = Dummy()
+        return self.as_relational(d).subs(d, other)
+
+    def as_relational(self, x):
+        """Rewrite an interval in terms of inequalities and logic operators."""
+        x = sympify(x)
+        if self.right_open:
+            right = x < self.end
+        else:
+            right = x <= self.end
+        if self.left_open:
+            left = self.start < x
+        else:
+            left = self.start <= x
+        return And(left, right)
+
+    @property
+    def _measure(self):
+        return self.end - self.start
+
+    def _kind(self):
+        return SetKind(NumberKind)
+
+    def to_mpi(self, prec=53):
+        return mpi(mpf(self.start._eval_evalf(prec)),
+            mpf(self.end._eval_evalf(prec)))
+
+    def _eval_evalf(self, prec):
+        return Interval(self.left._evalf(prec), self.right._evalf(prec),
+            left_open=self.left_open, right_open=self.right_open)
+
+    def _is_comparable(self, other):
+        is_comparable = self.start.is_comparable
+        is_comparable &= self.end.is_comparable
+        is_comparable &= other.start.is_comparable
+        is_comparable &= other.end.is_comparable
+
+        return is_comparable
+
+    @property
+    def is_left_unbounded(self):
+        """Return ``True`` if the left endpoint is negative infinity. """
+        return self.left is S.NegativeInfinity or self.left == Float("-inf")
+
+    @property
+    def is_right_unbounded(self):
+        """Return ``True`` if the right endpoint is positive infinity. """
+        return self.right is S.Infinity or self.right == Float("+inf")
+
+    def _eval_Eq(self, other):
+        if not isinstance(other, Interval):
+            if isinstance(other, FiniteSet):
+                return false
+            elif isinstance(other, Set):
+                return None
+            return false
+
+
+class Union(Set, LatticeOp):
+    """
+    Represents a union of sets as a :class:`Set`.
+
+    Examples
+    ========
+
+    >>> from sympy import Union, Interval
+    >>> Union(Interval(1, 2), Interval(3, 4))
+    Union(Interval(1, 2), Interval(3, 4))
+
+    The Union constructor will always try to merge overlapping intervals,
+    if possible. For example:
+
+    >>> Union(Interval(1, 2), Interval(2, 3))
+    Interval(1, 3)
+
+    See Also
+    ========
+
+    Intersection
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Union_%28set_theory%29
+    """
+    is_Union = True
+
+    @property
+    def identity(self):
+        return S.EmptySet
+
+    @property
+    def zero(self):
+        return S.UniversalSet
+
+    def __new__(cls, *args, **kwargs):
+        evaluate = kwargs.get('evaluate', global_parameters.evaluate)
+
+        # flatten inputs to merge intersections and iterables
+        args = _sympify(args)
+
+        # Reduce sets using known rules
+        if evaluate:
+            args = list(cls._new_args_filter(args))
+            return simplify_union(args)
+
+        args = list(ordered(args, Set._infimum_key))
+
+        obj = Basic.__new__(cls, *args)
+        obj._argset = frozenset(args)
+        return obj
+
+    @property
+    def args(self):
+        return self._args
+
+    def _complement(self, universe):
+        # DeMorgan's Law
+        return Intersection(s.complement(universe) for s in self.args)
+
+    @property
+    def _inf(self):
+        # We use Min so that sup is meaningful in combination with symbolic
+        # interval end points.
+        return Min(*[set.inf for set in self.args])
+
+    @property
+    def _sup(self):
+        # We use Max so that sup is meaningful in combination with symbolic
+        # end points.
+        return Max(*[set.sup for set in self.args])
+
+    @property
+    def is_empty(self):
+        return fuzzy_and(set.is_empty for set in self.args)
+
+    @property
+    def is_finite_set(self):
+        return fuzzy_and(set.is_finite_set for set in self.args)
+
+    @property
+    def _measure(self):
+        # Measure of a union is the sum of the measures of the sets minus
+        # the sum of their pairwise intersections plus the sum of their
+        # triple-wise intersections minus ... etc...
+
+        # Sets is a collection of intersections and a set of elementary
+        # sets which made up those intersections (called "sos" for set of sets)
+        # An example element might of this list might be:
+        #    ( {A,B,C}, A.intersect(B).intersect(C) )
+
+        # Start with just elementary sets (  ({A}, A), ({B}, B), ... )
+        # Then get and subtract (  ({A,B}, (A int B), ... ) while non-zero
+        sets = [(FiniteSet(s), s) for s in self.args]
+        measure = 0
+        parity = 1
+        while sets:
+            # Add up the measure of these sets and add or subtract it to total
+            measure += parity * sum(inter.measure for sos, inter in sets)
+
+            # For each intersection in sets, compute the intersection with every
+            # other set not already part of the intersection.
+            sets = ((sos + FiniteSet(newset), newset.intersect(intersection))
+                    for sos, intersection in sets for newset in self.args
+                    if newset not in sos)
+
+            # Clear out sets with no measure
+            sets = [(sos, inter) for sos, inter in sets if inter.measure != 0]
+
+            # Clear out duplicates
+            sos_list = []
+            sets_list = []
+            for _set in sets:
+                if _set[0] in sos_list:
+                    continue
+                else:
+                    sos_list.append(_set[0])
+                    sets_list.append(_set)
+            sets = sets_list
+
+            # Flip Parity - next time subtract/add if we added/subtracted here
+            parity *= -1
+        return measure
+
+    def _kind(self):
+        kinds = tuple(arg.kind for arg in self.args if arg is not S.EmptySet)
+        if not kinds:
+            return SetKind()
+        elif all(i == kinds[0] for i in kinds):
+            return kinds[0]
+        else:
+            return SetKind(UndefinedKind)
+
+    @property
+    def _boundary(self):
+        def boundary_of_set(i):
+            """ The boundary of set i minus interior of all other sets """
+            b = self.args[i].boundary
+            for j, a in enumerate(self.args):
+                if j != i:
+                    b = b - a.interior
+            return b
+        return Union(*map(boundary_of_set, range(len(self.args))))
+
+    def _contains(self, other):
+        return Or(*[s.contains(other) for s in self.args])
+
+    def is_subset(self, other):
+        return fuzzy_and(s.is_subset(other) for s in self.args)
+
+    def as_relational(self, symbol):
+        """Rewrite a Union in terms of equalities and logic operators. """
+        if (len(self.args) == 2 and
+                all(isinstance(i, Interval) for i in self.args)):
+            # optimization to give 3 args as (x > 1) & (x < 5) & Ne(x, 3)
+            # instead of as 4, ((1 <= x) & (x < 3)) | ((x <= 5) & (3 < x))
+            # XXX: This should be ideally be improved to handle any number of
+            # intervals and also not to assume that the intervals are in any
+            # particular sorted order.
+            a, b = self.args
+            if a.sup == b.inf and a.right_open and b.left_open:
+                mincond = symbol > a.inf if a.left_open else symbol >= a.inf
+                maxcond = symbol < b.sup if b.right_open else symbol <= b.sup
+                necond = Ne(symbol, a.sup)
+                return And(necond, mincond, maxcond)
+        return Or(*[i.as_relational(symbol) for i in self.args])
+
+    @property
+    def is_iterable(self):
+        return all(arg.is_iterable for arg in self.args)
+
+    def __iter__(self):
+        return roundrobin(*(iter(arg) for arg in self.args))
+
+
+class Intersection(Set, LatticeOp):
+    """
+    Represents an intersection of sets as a :class:`Set`.
+
+    Examples
+    ========
+
+    >>> from sympy import Intersection, Interval
+    >>> Intersection(Interval(1, 3), Interval(2, 4))
+    Interval(2, 3)
+
+    We often use the .intersect method
+
+    >>> Interval(1,3).intersect(Interval(2,4))
+    Interval(2, 3)
+
+    See Also
+    ========
+
+    Union
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Intersection_%28set_theory%29
+    """
+    is_Intersection = True
+
+    @property
+    def identity(self):
+        return S.UniversalSet
+
+    @property
+    def zero(self):
+        return S.EmptySet
+
+    def __new__(cls, *args, **kwargs):
+        evaluate = kwargs.get('evaluate', global_parameters.evaluate)
+
+        # flatten inputs to merge intersections and iterables
+        args = list(ordered(set(_sympify(args))))
+
+        # Reduce sets using known rules
+        if evaluate:
+            args = list(cls._new_args_filter(args))
+            return simplify_intersection(args)
+
+        args = list(ordered(args, Set._infimum_key))
+
+        obj = Basic.__new__(cls, *args)
+        obj._argset = frozenset(args)
+        return obj
+
+    @property
+    def args(self):
+        return self._args
+
+    @property
+    def is_iterable(self):
+        return any(arg.is_iterable for arg in self.args)
+
+    @property
+    def is_finite_set(self):
+        if fuzzy_or(arg.is_finite_set for arg in self.args):
+            return True
+
+    def _kind(self):
+        kinds = tuple(arg.kind for arg in self.args if arg is not S.UniversalSet)
+        if not kinds:
+            return SetKind(UndefinedKind)
+        elif all(i == kinds[0] for i in kinds):
+            return kinds[0]
+        else:
+            return SetKind()
+
+    @property
+    def _inf(self):
+        raise NotImplementedError()
+
+    @property
+    def _sup(self):
+        raise NotImplementedError()
+
+    def _contains(self, other):
+        return And(*[set.contains(other) for set in self.args])
+
+    def __iter__(self):
+        sets_sift = sift(self.args, lambda x: x.is_iterable)
+
+        completed = False
+        candidates = sets_sift[True] + sets_sift[None]
+
+        finite_candidates, others = [], []
+        for candidate in candidates:
+            length = None
+            try:
+                length = len(candidate)
+            except TypeError:
+                others.append(candidate)
+
+            if length is not None:
+                finite_candidates.append(candidate)
+        finite_candidates.sort(key=len)
+
+        for s in finite_candidates + others:
+            other_sets = set(self.args) - {s}
+            other = Intersection(*other_sets, evaluate=False)
+            completed = True
+            for x in s:
+                try:
+                    if x in other:
+                        yield x
+                except TypeError:
+                    completed = False
+            if completed:
+                return
+
+        if not completed:
+            if not candidates:
+                raise TypeError("None of the constituent sets are iterable")
+            raise TypeError(
+                "The computation had not completed because of the "
+                "undecidable set membership is found in every candidates.")
+
+    @staticmethod
+    def _handle_finite_sets(args):
+        '''Simplify intersection of one or more FiniteSets and other sets'''
+
+        # First separate the FiniteSets from the others
+        fs_args, others = sift(args, lambda x: x.is_FiniteSet, binary=True)
+
+        # Let the caller handle intersection of non-FiniteSets
+        if not fs_args:
+            return
+
+        # Convert to Python sets and build the set of all elements
+        fs_sets = [set(fs) for fs in fs_args]
+        all_elements = reduce(lambda a, b: a | b, fs_sets, set())
+
+        # Extract elements that are definitely in or definitely not in the
+        # intersection. Here we check contains for all of args.
+        definite = set()
+        for e in all_elements:
+            inall = fuzzy_and(s.contains(e) for s in args)
+            if inall is True:
+                definite.add(e)
+            if inall is not None:
+                for s in fs_sets:
+                    s.discard(e)
+
+        # At this point all elements in all of fs_sets are possibly in the
+        # intersection. In some cases this is because they are definitely in
+        # the intersection of the finite sets but it's not clear if they are
+        # members of others. We might have {m, n}, {m}, and Reals where we
+        # don't know if m or n is real. We want to remove n here but it is
+        # possibly in because it might be equal to m. So what we do now is
+        # extract the elements that are definitely in the remaining finite
+        # sets iteratively until we end up with {n}, {}. At that point if we
+        # get any empty set all remaining elements are discarded.
+
+        fs_elements = reduce(lambda a, b: a | b, fs_sets, set())
+
+        # Need fuzzy containment testing
+        fs_symsets = [FiniteSet(*s) for s in fs_sets]
+
+        while fs_elements:
+            for e in fs_elements:
+                infs = fuzzy_and(s.contains(e) for s in fs_symsets)
+                if infs is True:
+                    definite.add(e)
+                if infs is not None:
+                    for n, s in enumerate(fs_sets):
+                        # Update Python set and FiniteSet
+                        if e in s:
+                            s.remove(e)
+                            fs_symsets[n] = FiniteSet(*s)
+                    fs_elements.remove(e)
+                    break
+            # If we completed the for loop without removing anything we are
+            # done so quit the outer while loop
+            else:
+                break
+
+        # If any of the sets of remainder elements is empty then we discard
+        # all of them for the intersection.
+        if not all(fs_sets):
+            fs_sets = [set()]
+
+        # Here we fold back the definitely included elements into each fs.
+        # Since they are definitely included they must have been members of
+        # each FiniteSet to begin with. We could instead fold these in with a
+        # Union at the end to get e.g. {3}|({x}&{y}) rather than {3,x}&{3,y}.
+        if definite:
+            fs_sets = [fs | definite for fs in fs_sets]
+
+        if fs_sets == [set()]:
+            return S.EmptySet
+
+        sets = [FiniteSet(*s) for s in fs_sets]
+
+        # Any set in others is redundant if it contains all the elements that
+        # are in the finite sets so we don't need it in the Intersection
+        all_elements = reduce(lambda a, b: a | b, fs_sets, set())
+        is_redundant = lambda o: all(fuzzy_bool(o.contains(e)) for e in all_elements)
+        others = [o for o in others if not is_redundant(o)]
+
+        if others:
+            rest = Intersection(*others)
+            # XXX: Maybe this shortcut should be at the beginning. For large
+            # FiniteSets it could much more efficient to process the other
+            # sets first...
+            if rest is S.EmptySet:
+                return S.EmptySet
+            # Flatten the Intersection
+            if rest.is_Intersection:
+                sets.extend(rest.args)
+            else:
+                sets.append(rest)
+
+        if len(sets) == 1:
+            return sets[0]
+        else:
+            return Intersection(*sets, evaluate=False)
+
+    def as_relational(self, symbol):
+        """Rewrite an Intersection in terms of equalities and logic operators"""
+        return And(*[set.as_relational(symbol) for set in self.args])
+
+
+class Complement(Set):
+    r"""Represents the set difference or relative complement of a set with
+    another set.
+
+    $$A - B = \{x \in A \mid x \notin B\}$$
+
+
+    Examples
+    ========
+
+    >>> from sympy import Complement, FiniteSet
+    >>> Complement(FiniteSet(0, 1, 2), FiniteSet(1))
+    {0, 2}
+
+    See Also
+    =========
+
+    Intersection, Union
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/ComplementSet.html
+    """
+
+    is_Complement = True
+
+    def __new__(cls, a, b, evaluate=True):
+        a, b = map(_sympify, (a, b))
+        if evaluate:
+            return Complement.reduce(a, b)
+
+        return Basic.__new__(cls, a, b)
+
+    @staticmethod
+    def reduce(A, B):
+        """
+        Simplify a :class:`Complement`.
+
+        """
+        if B == S.UniversalSet or A.is_subset(B):
+            return S.EmptySet
+
+        if isinstance(B, Union):
+            return Intersection(*(s.complement(A) for s in B.args))
+
+        result = B._complement(A)
+        if result is not None:
+            return result
+        else:
+            return Complement(A, B, evaluate=False)
+
+    def _contains(self, other):
+        A = self.args[0]
+        B = self.args[1]
+        return And(A.contains(other), Not(B.contains(other)))
+
+    def as_relational(self, symbol):
+        """Rewrite a complement in terms of equalities and logic
+        operators"""
+        A, B = self.args
+
+        A_rel = A.as_relational(symbol)
+        B_rel = Not(B.as_relational(symbol))
+
+        return And(A_rel, B_rel)
+
+    def _kind(self):
+        return self.args[0].kind
+
+    @property
+    def is_iterable(self):
+        if self.args[0].is_iterable:
+            return True
+
+    @property
+    def is_finite_set(self):
+        A, B = self.args
+        a_finite = A.is_finite_set
+        if a_finite is True:
+            return True
+        elif a_finite is False and B.is_finite_set:
+            return False
+
+    def __iter__(self):
+        A, B = self.args
+        for a in A:
+            if a not in B:
+                    yield a
+            else:
+                continue
+
+
+class EmptySet(Set, metaclass=Singleton):
+    """
+    Represents the empty set. The empty set is available as a singleton
+    as ``S.EmptySet``.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Interval
+    >>> S.EmptySet
+    EmptySet
+
+    >>> Interval(1, 2).intersect(S.EmptySet)
+    EmptySet
+
+    See Also
+    ========
+
+    UniversalSet
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Empty_set
+    """
+    is_empty = True
+    is_finite_set = True
+    is_FiniteSet = True
+
+    @property  # type: ignore
+    @deprecated(
+        """
+        The is_EmptySet attribute of Set objects is deprecated.
+        Use 's is S.EmptySet" or 's.is_empty' instead.
+        """,
+        deprecated_since_version="1.5",
+        active_deprecations_target="deprecated-is-emptyset",
+    )
+    def is_EmptySet(self):
+        return True
+
+    @property
+    def _measure(self):
+        return 0
+
+    def _contains(self, other):
+        return false
+
+    def as_relational(self, symbol):
+        return false
+
+    def __len__(self):
+        return 0
+
+    def __iter__(self):
+        return iter([])
+
+    def _eval_powerset(self):
+        return FiniteSet(self)
+
+    @property
+    def _boundary(self):
+        return self
+
+    def _complement(self, other):
+        return other
+
+    def _kind(self):
+        return SetKind()
+
+    def _symmetric_difference(self, other):
+        return other
+
+
+class UniversalSet(Set, metaclass=Singleton):
+    """
+    Represents the set of all things.
+    The universal set is available as a singleton as ``S.UniversalSet``.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Interval
+    >>> S.UniversalSet
+    UniversalSet
+
+    >>> Interval(1, 2).intersect(S.UniversalSet)
+    Interval(1, 2)
+
+    See Also
+    ========
+
+    EmptySet
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Universal_set
+    """
+
+    is_UniversalSet = True
+    is_empty = False
+    is_finite_set = False
+
+    def _complement(self, other):
+        return S.EmptySet
+
+    def _symmetric_difference(self, other):
+        return other
+
+    @property
+    def _measure(self):
+        return S.Infinity
+
+    def _kind(self):
+        return SetKind(UndefinedKind)
+
+    def _contains(self, other):
+        return true
+
+    def as_relational(self, symbol):
+        return true
+
+    @property
+    def _boundary(self):
+        return S.EmptySet
+
+
+class FiniteSet(Set):
+    """
+    Represents a finite set of Sympy expressions.
+
+    Examples
+    ========
+
+    >>> from sympy import FiniteSet, Symbol, Interval, Naturals0
+    >>> FiniteSet(1, 2, 3, 4)
+    {1, 2, 3, 4}
+    >>> 3 in FiniteSet(1, 2, 3, 4)
+    True
+    >>> FiniteSet(1, (1, 2), Symbol('x'))
+    {1, x, (1, 2)}
+    >>> FiniteSet(Interval(1, 2), Naturals0, {1, 2})
+    FiniteSet({1, 2}, Interval(1, 2), Naturals0)
+    >>> members = [1, 2, 3, 4]
+    >>> f = FiniteSet(*members)
+    >>> f
+    {1, 2, 3, 4}
+    >>> f - FiniteSet(2)
+    {1, 3, 4}
+    >>> f + FiniteSet(2, 5)
+    {1, 2, 3, 4, 5}
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Finite_set
+    """
+    is_FiniteSet = True
+    is_iterable = True
+    is_empty = False
+    is_finite_set = True
+
+    def __new__(cls, *args, **kwargs):
+        evaluate = kwargs.get('evaluate', global_parameters.evaluate)
+        if evaluate:
+            args = list(map(sympify, args))
+
+            if len(args) == 0:
+                return S.EmptySet
+        else:
+            args = list(map(sympify, args))
+
+        # keep the form of the first canonical arg
+        dargs = {}
+        for i in reversed(list(ordered(args))):
+            if i.is_Symbol:
+                dargs[i] = i
+            else:
+                try:
+                    dargs[i.as_dummy()] = i
+                except TypeError:
+                    # e.g. i = class without args like `Interval`
+                    dargs[i] = i
+        _args_set = set(dargs.values())
+        args = list(ordered(_args_set, Set._infimum_key))
+        obj = Basic.__new__(cls, *args)
+        obj._args_set = _args_set
+        return obj
+
+
+    def __iter__(self):
+        return iter(self.args)
+
+    def _complement(self, other):
+        if isinstance(other, Interval):
+            # Splitting in sub-intervals is only done for S.Reals;
+            # other cases that need splitting will first pass through
+            # Set._complement().
+            nums, syms = [], []
+            for m in self.args:
+                if m.is_number and m.is_real:
+                    nums.append(m)
+                elif m.is_real == False:
+                    pass  # drop non-reals
+                else:
+                    syms.append(m)  # various symbolic expressions
+            if other == S.Reals and nums != []:
+                nums.sort()
+                intervals = []  # Build up a list of intervals between the elements
+                intervals += [Interval(S.NegativeInfinity, nums[0], True, True)]
+                for a, b in zip(nums[:-1], nums[1:]):
+                    intervals.append(Interval(a, b, True, True))  # both open
+                intervals.append(Interval(nums[-1], S.Infinity, True, True))
+                if syms != []:
+                    return Complement(Union(*intervals, evaluate=False),
+                            FiniteSet(*syms), evaluate=False)
+                else:
+                    return Union(*intervals, evaluate=False)
+            elif nums == []:  # no splitting necessary or possible:
+                if syms:
+                    return Complement(other, FiniteSet(*syms), evaluate=False)
+                else:
+                    return other
+
+        elif isinstance(other, FiniteSet):
+            unk = []
+            for i in self:
+                c = sympify(other.contains(i))
+                if c is not S.true and c is not S.false:
+                    unk.append(i)
+            unk = FiniteSet(*unk)
+            if unk == self:
+                return
+            not_true = []
+            for i in other:
+                c = sympify(self.contains(i))
+                if c is not S.true:
+                    not_true.append(i)
+            return Complement(FiniteSet(*not_true), unk)
+
+        return Set._complement(self, other)
+
+    def _contains(self, other):
+        """
+        Tests whether an element, other, is in the set.
+
+        Explanation
+        ===========
+
+        The actual test is for mathematical equality (as opposed to
+        syntactical equality). In the worst case all elements of the
+        set must be checked.
+
+        Examples
+        ========
+
+        >>> from sympy import FiniteSet
+        >>> 1 in FiniteSet(1, 2)
+        True
+        >>> 5 in FiniteSet(1, 2)
+        False
+
+        """
+        if other in self._args_set:
+            return True
+        else:
+            # evaluate=True is needed to override evaluate=False context;
+            # we need Eq to do the evaluation
+            return fuzzy_or(fuzzy_bool(Eq(e, other, evaluate=True))
+                for e in self.args)
+
+    def _eval_is_subset(self, other):
+        return fuzzy_and(other._contains(e) for e in self.args)
+
+    @property
+    def _boundary(self):
+        return self
+
+    @property
+    def _inf(self):
+        return Min(*self)
+
+    @property
+    def _sup(self):
+        return Max(*self)
+
+    @property
+    def measure(self):
+        return 0
+
+    def _kind(self):
+        if not self.args:
+            return SetKind()
+        elif all(i.kind == self.args[0].kind for i in self.args):
+            return SetKind(self.args[0].kind)
+        else:
+            return SetKind(UndefinedKind)
+
+    def __len__(self):
+        return len(self.args)
+
+    def as_relational(self, symbol):
+        """Rewrite a FiniteSet in terms of equalities and logic operators. """
+        return Or(*[Eq(symbol, elem) for elem in self])
+
+    def compare(self, other):
+        return (hash(self) - hash(other))
+
+    def _eval_evalf(self, prec):
+        dps = prec_to_dps(prec)
+        return FiniteSet(*[elem.evalf(n=dps) for elem in self])
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify import simplify
+        return FiniteSet(*[simplify(elem, **kwargs) for elem in self])
+
+    @property
+    def _sorted_args(self):
+        return self.args
+
+    def _eval_powerset(self):
+        return self.func(*[self.func(*s) for s in subsets(self.args)])
+
+    def _eval_rewrite_as_PowerSet(self, *args, **kwargs):
+        """Rewriting method for a finite set to a power set."""
+        from .powerset import PowerSet
+
+        is2pow = lambda n: bool(n and not n & (n - 1))
+        if not is2pow(len(self)):
+            return None
+
+        fs_test = lambda arg: isinstance(arg, Set) and arg.is_FiniteSet
+        if not all(fs_test(arg) for arg in args):
+            return None
+
+        biggest = max(args, key=len)
+        for arg in subsets(biggest.args):
+            arg_set = FiniteSet(*arg)
+            if arg_set not in args:
+                return None
+        return PowerSet(biggest)
+
+    def __ge__(self, other):
+        if not isinstance(other, Set):
+            raise TypeError("Invalid comparison of set with %s" % func_name(other))
+        return other.is_subset(self)
+
+    def __gt__(self, other):
+        if not isinstance(other, Set):
+            raise TypeError("Invalid comparison of set with %s" % func_name(other))
+        return self.is_proper_superset(other)
+
+    def __le__(self, other):
+        if not isinstance(other, Set):
+            raise TypeError("Invalid comparison of set with %s" % func_name(other))
+        return self.is_subset(other)
+
+    def __lt__(self, other):
+        if not isinstance(other, Set):
+            raise TypeError("Invalid comparison of set with %s" % func_name(other))
+        return self.is_proper_subset(other)
+
+    def __eq__(self, other):
+        if isinstance(other, (set, frozenset)):
+            return self._args_set == other
+        return super().__eq__(other)
+
+    __hash__ : Callable[[Basic], Any] = Basic.__hash__
+
+_sympy_converter[set] = lambda x: FiniteSet(*x)
+_sympy_converter[frozenset] = lambda x: FiniteSet(*x)
+
+
+class SymmetricDifference(Set):
+    """Represents the set of elements which are in either of the
+    sets and not in their intersection.
+
+    Examples
+    ========
+
+    >>> from sympy import SymmetricDifference, FiniteSet
+    >>> SymmetricDifference(FiniteSet(1, 2, 3), FiniteSet(3, 4, 5))
+    {1, 2, 4, 5}
+
+    See Also
+    ========
+
+    Complement, Union
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Symmetric_difference
+    """
+
+    is_SymmetricDifference = True
+
+    def __new__(cls, a, b, evaluate=True):
+        if evaluate:
+            return SymmetricDifference.reduce(a, b)
+
+        return Basic.__new__(cls, a, b)
+
+    @staticmethod
+    def reduce(A, B):
+        result = B._symmetric_difference(A)
+        if result is not None:
+            return result
+        else:
+            return SymmetricDifference(A, B, evaluate=False)
+
+    def as_relational(self, symbol):
+        """Rewrite a symmetric_difference in terms of equalities and
+        logic operators"""
+        A, B = self.args
+
+        A_rel = A.as_relational(symbol)
+        B_rel = B.as_relational(symbol)
+
+        return Xor(A_rel, B_rel)
+
+    @property
+    def is_iterable(self):
+        if all(arg.is_iterable for arg in self.args):
+            return True
+
+    def __iter__(self):
+
+        args = self.args
+        union = roundrobin(*(iter(arg) for arg in args))
+
+        for item in union:
+            count = 0
+            for s in args:
+                if item in s:
+                    count += 1
+
+            if count % 2 == 1:
+                yield item
+
+
+
+class DisjointUnion(Set):
+    """ Represents the disjoint union (also known as the external disjoint union)
+    of a finite number of sets.
+
+    Examples
+    ========
+
+    >>> from sympy import DisjointUnion, FiniteSet, Interval, Union, Symbol
+    >>> A = FiniteSet(1, 2, 3)
+    >>> B = Interval(0, 5)
+    >>> DisjointUnion(A, B)
+    DisjointUnion({1, 2, 3}, Interval(0, 5))
+    >>> DisjointUnion(A, B).rewrite(Union)
+    Union(ProductSet({1, 2, 3}, {0}), ProductSet(Interval(0, 5), {1}))
+    >>> C = FiniteSet(Symbol('x'), Symbol('y'), Symbol('z'))
+    >>> DisjointUnion(C, C)
+    DisjointUnion({x, y, z}, {x, y, z})
+    >>> DisjointUnion(C, C).rewrite(Union)
+    ProductSet({x, y, z}, {0, 1})
+
+    References
+    ==========
+
+    https://en.wikipedia.org/wiki/Disjoint_union
+    """
+
+    def __new__(cls, *sets):
+        dj_collection = []
+        for set_i in sets:
+            if isinstance(set_i, Set):
+                dj_collection.append(set_i)
+            else:
+                raise TypeError("Invalid input: '%s', input args \
+                    to DisjointUnion must be Sets" % set_i)
+        obj = Basic.__new__(cls, *dj_collection)
+        return obj
+
+    @property
+    def sets(self):
+        return self.args
+
+    @property
+    def is_empty(self):
+        return fuzzy_and(s.is_empty for s in self.sets)
+
+    @property
+    def is_finite_set(self):
+        all_finite = fuzzy_and(s.is_finite_set for s in self.sets)
+        return fuzzy_or([self.is_empty, all_finite])
+
+    @property
+    def is_iterable(self):
+        if self.is_empty:
+            return False
+        iter_flag = True
+        for set_i in self.sets:
+            if not set_i.is_empty:
+                iter_flag = iter_flag and set_i.is_iterable
+        return iter_flag
+
+    def _eval_rewrite_as_Union(self, *sets):
+        """
+        Rewrites the disjoint union as the union of (``set`` x {``i``})
+        where ``set`` is the element in ``sets`` at index = ``i``
+        """
+
+        dj_union = S.EmptySet
+        index = 0
+        for set_i in sets:
+            if isinstance(set_i, Set):
+                cross = ProductSet(set_i, FiniteSet(index))
+                dj_union = Union(dj_union, cross)
+                index = index + 1
+        return dj_union
+
+    def _contains(self, element):
+        """
+        ``in`` operator for DisjointUnion
+
+        Examples
+        ========
+
+        >>> from sympy import Interval, DisjointUnion
+        >>> D = DisjointUnion(Interval(0, 1), Interval(0, 2))
+        >>> (0.5, 0) in D
+        True
+        >>> (0.5, 1) in D
+        True
+        >>> (1.5, 0) in D
+        False
+        >>> (1.5, 1) in D
+        True
+
+        Passes operation on to constituent sets
+        """
+        if not isinstance(element, Tuple) or len(element) != 2:
+            return False
+
+        if not element[1].is_Integer:
+            return False
+
+        if element[1] >= len(self.sets) or element[1] < 0:
+            return False
+
+        return element[0] in self.sets[element[1]]
+
+    def _kind(self):
+        if not self.args:
+            return SetKind()
+        elif all(i.kind == self.args[0].kind for i in self.args):
+            return self.args[0].kind
+        else:
+            return SetKind(UndefinedKind)
+
+    def __iter__(self):
+        if self.is_iterable:
+
+            iters = []
+            for i, s in enumerate(self.sets):
+                iters.append(iproduct(s, {Integer(i)}))
+
+            return iter(roundrobin(*iters))
+        else:
+            raise ValueError("'%s' is not iterable." % self)
+
+    def __len__(self):
+        """
+        Returns the length of the disjoint union, i.e., the number of elements in the set.
+
+        Examples
+        ========
+
+        >>> from sympy import FiniteSet, DisjointUnion, EmptySet
+        >>> D1 = DisjointUnion(FiniteSet(1, 2, 3, 4), EmptySet, FiniteSet(3, 4, 5))
+        >>> len(D1)
+        7
+        >>> D2 = DisjointUnion(FiniteSet(3, 5, 7), EmptySet, FiniteSet(3, 5, 7))
+        >>> len(D2)
+        6
+        >>> D3 = DisjointUnion(EmptySet, EmptySet)
+        >>> len(D3)
+        0
+
+        Adds up the lengths of the constituent sets.
+        """
+
+        if self.is_finite_set:
+            size = 0
+            for set in self.sets:
+                size += len(set)
+            return size
+        else:
+            raise ValueError("'%s' is not a finite set." % self)
+
+
+def imageset(*args):
+    r"""
+    Return an image of the set under transformation ``f``.
+
+    Explanation
+    ===========
+
+    If this function cannot compute the image, it returns an
+    unevaluated ImageSet object.
+
+    .. math::
+        \{ f(x) \mid x \in \mathrm{self} \}
+
+    Examples
+    ========
+
+    >>> from sympy import S, Interval, imageset, sin, Lambda
+    >>> from sympy.abc import x
+
+    >>> imageset(x, 2*x, Interval(0, 2))
+    Interval(0, 4)
+
+    >>> imageset(lambda x: 2*x, Interval(0, 2))
+    Interval(0, 4)
+
+    >>> imageset(Lambda(x, sin(x)), Interval(-2, 1))
+    ImageSet(Lambda(x, sin(x)), Interval(-2, 1))
+
+    >>> imageset(sin, Interval(-2, 1))
+    ImageSet(Lambda(x, sin(x)), Interval(-2, 1))
+    >>> imageset(lambda y: x + y, Interval(-2, 1))
+    ImageSet(Lambda(y, x + y), Interval(-2, 1))
+
+    Expressions applied to the set of Integers are simplified
+    to show as few negatives as possible and linear expressions
+    are converted to a canonical form. If this is not desirable
+    then the unevaluated ImageSet should be used.
+
+    >>> imageset(x, -2*x + 5, S.Integers)
+    ImageSet(Lambda(x, 2*x + 1), Integers)
+
+    See Also
+    ========
+
+    sympy.sets.fancysets.ImageSet
+
+    """
+    from .fancysets import ImageSet
+    from .setexpr import set_function
+
+    if len(args) < 2:
+        raise ValueError('imageset expects at least 2 args, got: %s' % len(args))
+
+    if isinstance(args[0], (Symbol, tuple)) and len(args) > 2:
+        f = Lambda(args[0], args[1])
+        set_list = args[2:]
+    else:
+        f = args[0]
+        set_list = args[1:]
+
+    if isinstance(f, Lambda):
+        pass
+    elif callable(f):
+        nargs = getattr(f, 'nargs', {})
+        if nargs:
+            if len(nargs) != 1:
+                raise NotImplementedError(filldedent('''
+                    This function can take more than 1 arg
+                    but the potentially complicated set input
+                    has not been analyzed at this point to
+                    know its dimensions. TODO
+                    '''))
+            N = nargs.args[0]
+            if N == 1:
+                s = 'x'
+            else:
+                s = [Symbol('x%i' % i) for i in range(1, N + 1)]
+        else:
+            s = inspect.signature(f).parameters
+
+        dexpr = _sympify(f(*[Dummy() for i in s]))
+        var = tuple(uniquely_named_symbol(
+            Symbol(i), dexpr) for i in s)
+        f = Lambda(var, f(*var))
+    else:
+        raise TypeError(filldedent('''
+            expecting lambda, Lambda, or FunctionClass,
+            not \'%s\'.''' % func_name(f)))
+
+    if any(not isinstance(s, Set) for s in set_list):
+        name = [func_name(s) for s in set_list]
+        raise ValueError(
+            'arguments after mapping should be sets, not %s' % name)
+
+    if len(set_list) == 1:
+        set = set_list[0]
+        try:
+            # TypeError if arg count != set dimensions
+            r = set_function(f, set)
+            if r is None:
+                raise TypeError
+            if not r:
+                return r
+        except TypeError:
+            r = ImageSet(f, set)
+        if isinstance(r, ImageSet):
+            f, set = r.args
+
+        if f.variables[0] == f.expr:
+            return set
+
+        if isinstance(set, ImageSet):
+            # XXX: Maybe this should just be:
+            # f2 = set.lambda
+            # fun = Lambda(f2.signature, f(*f2.expr))
+            # return imageset(fun, *set.base_sets)
+            if len(set.lamda.variables) == 1 and len(f.variables) == 1:
+                x = set.lamda.variables[0]
+                y = f.variables[0]
+                return imageset(
+                    Lambda(x, f.expr.subs(y, set.lamda.expr)), *set.base_sets)
+
+        if r is not None:
+            return r
+
+    return ImageSet(f, *set_list)
+
+
+def is_function_invertible_in_set(func, setv):
+    """
+    Checks whether function ``func`` is invertible when the domain is
+    restricted to set ``setv``.
+    """
+    # Functions known to always be invertible:
+    if func in (exp, log):
+        return True
+    u = Dummy("u")
+    fdiff = func(u).diff(u)
+    # monotonous functions:
+    # TODO: check subsets (`func` in `setv`)
+    if (fdiff > 0) == True or (fdiff < 0) == True:
+        return True
+    # TODO: support more
+    return None
+
+
+def simplify_union(args):
+    """
+    Simplify a :class:`Union` using known rules.
+
+    Explanation
+    ===========
+
+    We first start with global rules like 'Merge all FiniteSets'
+
+    Then we iterate through all pairs and ask the constituent sets if they
+    can simplify themselves with any other constituent.  This process depends
+    on ``union_sets(a, b)`` functions.
+    """
+    from sympy.sets.handlers.union import union_sets
+
+    # ===== Global Rules =====
+    if not args:
+        return S.EmptySet
+
+    for arg in args:
+        if not isinstance(arg, Set):
+            raise TypeError("Input args to Union must be Sets")
+
+    # Merge all finite sets
+    finite_sets = [x for x in args if x.is_FiniteSet]
+    if len(finite_sets) > 1:
+        a = (x for set in finite_sets for x in set)
+        finite_set = FiniteSet(*a)
+        args = [finite_set] + [x for x in args if not x.is_FiniteSet]
+
+    # ===== Pair-wise Rules =====
+    # Here we depend on rules built into the constituent sets
+    args = set(args)
+    new_args = True
+    while new_args:
+        for s in args:
+            new_args = False
+            for t in args - {s}:
+                new_set = union_sets(s, t)
+                # This returns None if s does not know how to intersect
+                # with t. Returns the newly intersected set otherwise
+                if new_set is not None:
+                    if not isinstance(new_set, set):
+                        new_set = {new_set}
+                    new_args = (args - {s, t}).union(new_set)
+                    break
+            if new_args:
+                args = new_args
+                break
+
+    if len(args) == 1:
+        return args.pop()
+    else:
+        return Union(*args, evaluate=False)
+
+
+def simplify_intersection(args):
+    """
+    Simplify an intersection using known rules.
+
+    Explanation
+    ===========
+
+    We first start with global rules like
+    'if any empty sets return empty set' and 'distribute any unions'
+
+    Then we iterate through all pairs and ask the constituent sets if they
+    can simplify themselves with any other constituent
+    """
+
+    # ===== Global Rules =====
+    if not args:
+        return S.UniversalSet
+
+    for arg in args:
+        if not isinstance(arg, Set):
+            raise TypeError("Input args to Union must be Sets")
+
+    # If any EmptySets return EmptySet
+    if S.EmptySet in args:
+        return S.EmptySet
+
+    # Handle Finite sets
+    rv = Intersection._handle_finite_sets(args)
+
+    if rv is not None:
+        return rv
+
+    # If any of the sets are unions, return a Union of Intersections
+    for s in args:
+        if s.is_Union:
+            other_sets = set(args) - {s}
+            if len(other_sets) > 0:
+                other = Intersection(*other_sets)
+                return Union(*(Intersection(arg, other) for arg in s.args))
+            else:
+                return Union(*s.args)
+
+    for s in args:
+        if s.is_Complement:
+            args.remove(s)
+            other_sets = args + [s.args[0]]
+            return Complement(Intersection(*other_sets), s.args[1])
+
+    from sympy.sets.handlers.intersection import intersection_sets
+
+    # At this stage we are guaranteed not to have any
+    # EmptySets, FiniteSets, or Unions in the intersection
+
+    # ===== Pair-wise Rules =====
+    # Here we depend on rules built into the constituent sets
+    args = set(args)
+    new_args = True
+    while new_args:
+        for s in args:
+            new_args = False
+            for t in args - {s}:
+                new_set = intersection_sets(s, t)
+                # This returns None if s does not know how to intersect
+                # with t. Returns the newly intersected set otherwise
+
+                if new_set is not None:
+                    new_args = (args - {s, t}).union({new_set})
+                    break
+            if new_args:
+                args = new_args
+                break
+
+    if len(args) == 1:
+        return args.pop()
+    else:
+        return Intersection(*args, evaluate=False)
+
+
+def _handle_finite_sets(op, x, y, commutative):
+    # Handle finite sets:
+    fs_args, other = sift([x, y], lambda x: isinstance(x, FiniteSet), binary=True)
+    if len(fs_args) == 2:
+        return FiniteSet(*[op(i, j) for i in fs_args[0] for j in fs_args[1]])
+    elif len(fs_args) == 1:
+        sets = [_apply_operation(op, other[0], i, commutative) for i in fs_args[0]]
+        return Union(*sets)
+    else:
+        return None
+
+
+def _apply_operation(op, x, y, commutative):
+    from .fancysets import ImageSet
+    d = Dummy('d')
+
+    out = _handle_finite_sets(op, x, y, commutative)
+    if out is None:
+        out = op(x, y)
+
+    if out is None and commutative:
+        out = op(y, x)
+    if out is None:
+        _x, _y = symbols("x y")
+        if isinstance(x, Set) and not isinstance(y, Set):
+            out = ImageSet(Lambda(d, op(d, y)), x).doit()
+        elif not isinstance(x, Set) and isinstance(y, Set):
+            out = ImageSet(Lambda(d, op(x, d)), y).doit()
+        else:
+            out = ImageSet(Lambda((_x, _y), op(_x, _y)), x, y)
+    return out
+
+
+def set_add(x, y):
+    from sympy.sets.handlers.add import _set_add
+    return _apply_operation(_set_add, x, y, commutative=True)
+
+
+def set_sub(x, y):
+    from sympy.sets.handlers.add import _set_sub
+    return _apply_operation(_set_sub, x, y, commutative=False)
+
+
+def set_mul(x, y):
+    from sympy.sets.handlers.mul import _set_mul
+    return _apply_operation(_set_mul, x, y, commutative=True)
+
+
+def set_div(x, y):
+    from sympy.sets.handlers.mul import _set_div
+    return _apply_operation(_set_div, x, y, commutative=False)
+
+
+def set_pow(x, y):
+    from sympy.sets.handlers.power import _set_pow
+    return _apply_operation(_set_pow, x, y, commutative=False)
+
+
+def set_function(f, x):
+    from sympy.sets.handlers.functions import _set_function
+    return _set_function(f, x)
+
+
+class SetKind(Kind):
+    """
+    SetKind is kind for all Sets
+
+    Every instance of Set will have kind ``SetKind`` parametrised by the kind
+    of the elements of the ``Set``. The kind of the elements might be
+    ``NumberKind``, or ``TupleKind`` or something else. When not all elements
+    have the same kind then the kind of the elements will be given as
+    ``UndefinedKind``.
+
+    Parameters
+    ==========
+
+    element_kind: Kind (optional)
+        The kind of the elements of the set. In a well defined set all elements
+        will have the same kind. Otherwise the kind should
+        :class:`sympy.core.kind.UndefinedKind`. The ``element_kind`` argument is optional but
+        should only be omitted in the case of ``EmptySet`` whose kind is simply
+        ``SetKind()``
+
+    Examples
+    ========
+
+    >>> from sympy import Interval
+    >>> Interval(1, 2).kind
+    SetKind(NumberKind)
+    >>> Interval(1,2).kind.element_kind
+    NumberKind
+
+    See Also
+    ========
+
+    sympy.core.kind.NumberKind
+    sympy.matrices.common.MatrixKind
+    sympy.core.containers.TupleKind
+    """
+    def __new__(cls, element_kind=None):
+        obj = super().__new__(cls, element_kind)
+        obj.element_kind = element_kind
+        return obj
+
+    def __repr__(self):
+        if not self.element_kind:
+            return "SetKind()"
+        else:
+            return "SetKind(%s)" % self.element_kind

env-llmeval/lib/python3.10/site-packages/sympy/sets/tests/test_conditionset.py

@@ -0,0 +1,294 @@
+from sympy.core.expr import unchanged
+from sympy.sets import (ConditionSet, Intersection, FiniteSet,
+    EmptySet, Union, Contains, ImageSet)
+from sympy.sets.sets import SetKind
+from sympy.core.function import (Function, Lambda)
+from sympy.core.mod import Mod
+from sympy.core.kind import NumberKind
+from sympy.core.numbers import (oo, pi)
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.trigonometric import (asin, sin)
+from sympy.logic.boolalg import And
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.sets.sets import Interval
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+
+w = Symbol('w')
+x = Symbol('x')
+y = Symbol('y')
+z = Symbol('z')
+f = Function('f')
+
+
+def test_CondSet():
+    sin_sols_principal = ConditionSet(x, Eq(sin(x), 0),
+                                      Interval(0, 2*pi, False, True))
+    assert pi in sin_sols_principal
+    assert pi/2 not in sin_sols_principal
+    assert 3*pi not in sin_sols_principal
+    assert oo not in sin_sols_principal
+    assert 5 in ConditionSet(x, x**2 > 4, S.Reals)
+    assert 1 not in ConditionSet(x, x**2 > 4, S.Reals)
+    # in this case, 0 is not part of the base set so
+    # it can't be in any subset selected by the condition
+    assert 0 not in ConditionSet(x, y > 5, Interval(1, 7))
+    # since 'in' requires a true/false, the following raises
+    # an error because the given value provides no information
+    # for the condition to evaluate (since the condition does
+    # not depend on the dummy symbol): the result is `y > 5`.
+    # In this case, ConditionSet is just acting like
+    # Piecewise((Interval(1, 7), y > 5), (S.EmptySet, True)).
+    raises(TypeError, lambda: 6 in ConditionSet(x, y > 5,
+        Interval(1, 7)))
+
+    X = MatrixSymbol('X', 2, 2)
+    matrix_set = ConditionSet(X, Eq(X*Matrix([[1, 1], [1, 1]]), X))
+    Y = Matrix([[0, 0], [0, 0]])
+    assert matrix_set.contains(Y).doit() is S.true
+    Z = Matrix([[1, 2], [3, 4]])
+    assert matrix_set.contains(Z).doit() is S.false
+
+    assert isinstance(ConditionSet(x, x < 1, {x, y}).base_set,
+        FiniteSet)
+    raises(TypeError, lambda: ConditionSet(x, x + 1, {x, y}))
+    raises(TypeError, lambda: ConditionSet(x, x, 1))
+
+    I = S.Integers
+    U = S.UniversalSet
+    C = ConditionSet
+    assert C(x, False, I) is S.EmptySet
+    assert C(x, True, I) is I
+    assert C(x, x < 1, C(x, x < 2, I)
+        ) == C(x, (x < 1) & (x < 2), I)
+    assert C(y, y < 1, C(x, y < 2, I)
+        ) == C(x, (x < 1) & (y < 2), I), C(y, y < 1, C(x, y < 2, I))
+    assert C(y, y < 1, C(x, x < 2, I)
+        ) == C(y, (y < 1) & (y < 2), I)
+    assert C(y, y < 1, C(x, y < x, I)
+        ) == C(x, (x < 1) & (y < x), I)
+    assert unchanged(C, y, x < 1, C(x, y < x, I))
+    assert ConditionSet(x, x < 1).base_set is U
+    # arg checking is not done at instantiation but this
+    # will raise an error when containment is tested
+    assert ConditionSet((x,), x < 1).base_set is U
+
+    c = ConditionSet((x, y), x < y, I**2)
+    assert (1, 2) in c
+    assert (1, pi) not in c
+
+    raises(TypeError, lambda: C(x, x > 1, C((x, y), x > 1, I**2)))
+    # signature mismatch since only 3 args are accepted
+    raises(TypeError, lambda: C((x, y), x + y < 2, U, U))
+
+
+def test_CondSet_intersect():
+    input_conditionset = ConditionSet(x, x**2 > 4, Interval(1, 4, False,
+        False))
+    other_domain = Interval(0, 3, False, False)
+    output_conditionset = ConditionSet(x, x**2 > 4, Interval(
+        1, 3, False, False))
+    assert Intersection(input_conditionset, other_domain
+        ) == output_conditionset
+
+
+def test_issue_9849():
+    assert ConditionSet(x, Eq(x, x), S.Naturals
+        ) is S.Naturals
+    assert ConditionSet(x, Eq(Abs(sin(x)), -1), S.Naturals
+        ) == S.EmptySet
+
+
+def test_simplified_FiniteSet_in_CondSet():
+    assert ConditionSet(x, And(x < 1, x > -3), FiniteSet(0, 1, 2)
+        ) == FiniteSet(0)
+    assert ConditionSet(x, x < 0, FiniteSet(0, 1, 2)) == EmptySet
+    assert ConditionSet(x, And(x < -3), EmptySet) == EmptySet
+    y = Symbol('y')
+    assert (ConditionSet(x, And(x > 0), FiniteSet(-1, 0, 1, y)) ==
+        Union(FiniteSet(1), ConditionSet(x, And(x > 0), FiniteSet(y))))
+    assert (ConditionSet(x, Eq(Mod(x, 3), 1), FiniteSet(1, 4, 2, y)) ==
+        Union(FiniteSet(1, 4), ConditionSet(x, Eq(Mod(x, 3), 1),
+        FiniteSet(y))))
+
+
+def test_free_symbols():
+    assert ConditionSet(x, Eq(y, 0), FiniteSet(z)
+        ).free_symbols == {y, z}
+    assert ConditionSet(x, Eq(x, 0), FiniteSet(z)
+        ).free_symbols == {z}
+    assert ConditionSet(x, Eq(x, 0), FiniteSet(x, z)
+        ).free_symbols == {x, z}
+    assert ConditionSet(x, Eq(x, 0), ImageSet(Lambda(y, y**2),
+        S.Integers)).free_symbols == set()
+
+
+def test_bound_symbols():
+    assert ConditionSet(x, Eq(y, 0), FiniteSet(z)
+        ).bound_symbols == [x]
+    assert ConditionSet(x, Eq(x, 0), FiniteSet(x, y)
+        ).bound_symbols == [x]
+    assert ConditionSet(x, x < 10, ImageSet(Lambda(y, y**2), S.Integers)
+        ).bound_symbols == [x]
+    assert ConditionSet(x, x < 10, ConditionSet(y, y > 1, S.Integers)
+        ).bound_symbols == [x]
+
+
+def test_as_dummy():
+    _0, _1 = symbols('_0 _1')
+    assert ConditionSet(x, x < 1, Interval(y, oo)
+        ).as_dummy() == ConditionSet(_0, _0 < 1, Interval(y, oo))
+    assert ConditionSet(x, x < 1, Interval(x, oo)
+        ).as_dummy() == ConditionSet(_0, _0 < 1, Interval(x, oo))
+    assert ConditionSet(x, x < 1, ImageSet(Lambda(y, y**2), S.Integers)
+        ).as_dummy() == ConditionSet(
+            _0, _0 < 1, ImageSet(Lambda(_0, _0**2), S.Integers))
+    e = ConditionSet((x, y), x <= y, S.Reals**2)
+    assert e.bound_symbols == [x, y]
+    assert e.as_dummy() == ConditionSet((_0, _1), _0 <= _1, S.Reals**2)
+    assert e.as_dummy() == ConditionSet((y, x), y <= x, S.Reals**2
+        ).as_dummy()
+
+
+def test_subs_CondSet():
+    s = FiniteSet(z, y)
+    c = ConditionSet(x, x < 2, s)
+    assert c.subs(x, y) == c
+    assert c.subs(z, y) == ConditionSet(x, x < 2, FiniteSet(y))
+    assert c.xreplace({x: y}) == ConditionSet(y, y < 2, s)
+
+    assert ConditionSet(x, x < y, s
+        ).subs(y, w) == ConditionSet(x, x < w, s.subs(y, w))
+    # if the user uses assumptions that cause the condition
+    # to evaluate, that can't be helped from SymPy's end
+    n = Symbol('n', negative=True)
+    assert ConditionSet(n, 0 < n, S.Integers) is S.EmptySet
+    p = Symbol('p', positive=True)
+    assert ConditionSet(n, n < y, S.Integers
+        ).subs(n, x) == ConditionSet(n, n < y, S.Integers)
+    raises(ValueError, lambda: ConditionSet(
+        x + 1, x < 1, S.Integers))
+    assert ConditionSet(
+        p, n < x, Interval(-5, 5)).subs(x, p) == Interval(-5, 5), ConditionSet(
+        p, n < x, Interval(-5, 5)).subs(x, p)
+    assert ConditionSet(
+        n, n < x, Interval(-oo, 0)).subs(x, p
+        ) == Interval(-oo, 0)
+
+    assert ConditionSet(f(x), f(x) < 1, {w, z}
+        ).subs(f(x), y) == ConditionSet(f(x), f(x) < 1, {w, z})
+
+    # issue 17341
+    k = Symbol('k')
+    img1 = ImageSet(Lambda(k, 2*k*pi + asin(y)), S.Integers)
+    img2 = ImageSet(Lambda(k, 2*k*pi + asin(S.One/3)), S.Integers)
+    assert ConditionSet(x, Contains(
+        y, Interval(-1,1)), img1).subs(y, S.One/3).dummy_eq(img2)
+
+    assert (0, 1) in ConditionSet((x, y), x + y < 3, S.Integers**2)
+
+    raises(TypeError, lambda: ConditionSet(n, n < -10, Interval(0, 10)))
+
+
+def test_subs_CondSet_tebr():
+    with warns_deprecated_sympy():
+        assert ConditionSet((x, y), {x + 1, x + y}, S.Reals**2) == \
+            ConditionSet((x, y), Eq(x + 1, 0) & Eq(x + y, 0), S.Reals**2)
+
+
+def test_dummy_eq():
+    C = ConditionSet
+    I = S.Integers
+    c = C(x, x < 1, I)
+    assert c.dummy_eq(C(y, y < 1, I))
+    assert c.dummy_eq(1) == False
+    assert c.dummy_eq(C(x, x < 1, S.Reals)) == False
+
+    c1 = ConditionSet((x, y), Eq(x + 1, 0) & Eq(x + y, 0), S.Reals**2)
+    c2 = ConditionSet((x, y), Eq(x + 1, 0) & Eq(x + y, 0), S.Reals**2)
+    c3 = ConditionSet((x, y), Eq(x + 1, 0) & Eq(x + y, 0), S.Complexes**2)
+    assert c1.dummy_eq(c2)
+    assert c1.dummy_eq(c3) is False
+    assert c.dummy_eq(c1) is False
+    assert c1.dummy_eq(c) is False
+
+    # issue 19496
+    m = Symbol('m')
+    n = Symbol('n')
+    a = Symbol('a')
+    d1 = ImageSet(Lambda(m, m*pi), S.Integers)
+    d2 = ImageSet(Lambda(n, n*pi), S.Integers)
+    c1 = ConditionSet(x, Ne(a, 0), d1)
+    c2 = ConditionSet(x, Ne(a, 0), d2)
+    assert c1.dummy_eq(c2)
+
+
+def test_contains():
+    assert 6 in ConditionSet(x, x > 5, Interval(1, 7))
+    assert (8 in ConditionSet(x, y > 5, Interval(1, 7))) is False
+    # `in` should give True or False; in this case there is not
+    # enough information for that result
+    raises(TypeError,
+        lambda: 6 in ConditionSet(x, y > 5, Interval(1, 7)))
+    # here, there is enough information but the comparison is
+    # not defined
+    raises(TypeError, lambda: 0 in ConditionSet(x, 1/x >= 0, S.Reals))
+    assert ConditionSet(x, y > 5, Interval(1, 7)
+        ).contains(6) == (y > 5)
+    assert ConditionSet(x, y > 5, Interval(1, 7)
+        ).contains(8) is S.false
+    assert ConditionSet(x, y > 5, Interval(1, 7)
+        ).contains(w) == And(Contains(w, Interval(1, 7)), y > 5)
+    # This returns an unevaluated Contains object
+    # because 1/0 should not be defined for 1 and 0 in the context of
+    # reals.
+    assert ConditionSet(x, 1/x >= 0, S.Reals).contains(0) == \
+        Contains(0, ConditionSet(x, 1/x >= 0, S.Reals), evaluate=False)
+    c = ConditionSet((x, y), x + y > 1, S.Integers**2)
+    assert not c.contains(1)
+    assert c.contains((2, 1))
+    assert not c.contains((0, 1))
+    c = ConditionSet((w, (x, y)), w + x + y > 1, S.Integers*S.Integers**2)
+    assert not c.contains(1)
+    assert not c.contains((1, 2))
+    assert not c.contains(((1, 2), 3))
+    assert not c.contains(((1, 2), (3, 4)))
+    assert c.contains((1, (3, 4)))
+
+
+def test_as_relational():
+    assert ConditionSet((x, y), x > 1, S.Integers**2).as_relational((x, y)
+        ) == (x > 1) & Contains((x, y), S.Integers**2)
+    assert ConditionSet(x, x > 1, S.Integers).as_relational(x
+        ) == Contains(x, S.Integers) & (x > 1)
+
+
+def test_flatten():
+    """Tests whether there is basic denesting functionality"""
+    inner = ConditionSet(x, sin(x) + x > 0)
+    outer = ConditionSet(x, Contains(x, inner), S.Reals)
+    assert outer == ConditionSet(x, sin(x) + x > 0, S.Reals)
+
+    inner = ConditionSet(y, sin(y) + y > 0)
+    outer = ConditionSet(x, Contains(y, inner), S.Reals)
+    assert outer != ConditionSet(x, sin(x) + x > 0, S.Reals)
+
+    inner = ConditionSet(x, sin(x) + x > 0).intersect(Interval(-1, 1))
+    outer = ConditionSet(x, Contains(x, inner), S.Reals)
+    assert outer == ConditionSet(x, sin(x) + x > 0, Interval(-1, 1))
+
+
+def test_duplicate():
+    from sympy.core.function import BadSignatureError
+    # test coverage for line 95 in conditionset.py, check for duplicates in symbols
+    dup = symbols('a,a')
+    raises(BadSignatureError, lambda: ConditionSet(dup, x < 0))
+
+
+def test_SetKind_ConditionSet():
+    assert ConditionSet(x, Eq(sin(x), 0), Interval(0, 2*pi)).kind is SetKind(NumberKind)
+    assert ConditionSet(x, x < 0).kind is SetKind(NumberKind)

env-llmeval/lib/python3.10/site-packages/sympy/sets/tests/test_contains.py

@@ -0,0 +1,50 @@
+from sympy.core.expr import unchanged
+from sympy.core.numbers import oo
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.sets.contains import Contains
+from sympy.sets.sets import (FiniteSet, Interval)
+from sympy.testing.pytest import raises
+
+def test_contains_basic():
+    raises(TypeError, lambda: Contains(S.Integers, 1))
+    assert Contains(2, S.Integers) is S.true
+    assert Contains(-2, S.Naturals) is S.false
+
+    i = Symbol('i', integer=True)
+    assert Contains(i, S.Naturals) == Contains(i, S.Naturals, evaluate=False)
+
+
+def test_issue_6194():
+    x = Symbol('x')
+    assert unchanged(Contains, x, Interval(0, 1))
+    assert Interval(0, 1).contains(x) == (S.Zero <= x) & (x <= 1)
+    assert Contains(x, FiniteSet(0)) != S.false
+    assert Contains(x, Interval(1, 1)) != S.false
+    assert Contains(x, S.Integers) != S.false
+
+
+def test_issue_10326():
+    assert Contains(oo, Interval(-oo, oo)) == False
+    assert Contains(-oo, Interval(-oo, oo)) == False
+
+
+def test_binary_symbols():
+    x = Symbol('x')
+    y = Symbol('y')
+    z = Symbol('z')
+    assert Contains(x, FiniteSet(y, Eq(z, True))
+        ).binary_symbols == {y, z}
+
+
+def test_as_set():
+    x = Symbol('x')
+    y = Symbol('y')
+    assert Contains(x, FiniteSet(y)).as_set() == FiniteSet(y)
+    assert Contains(x, S.Integers).as_set() == S.Integers
+    assert Contains(x, S.Reals).as_set() == S.Reals
+
+def test_type_error():
+    # Pass in a parameter not of type "set"
+    raises(TypeError, lambda: Contains(2, None))