diff --git a/vllm/lib/python3.10/site-packages/sympy/core/__pycache__/intfunc.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/core/__pycache__/intfunc.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3b57b6a1e5ee14986a4e46441c7478b73e908837
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/core/__pycache__/intfunc.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/core/__pycache__/operations.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/core/__pycache__/operations.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c3638afa16b2134323f03274c00c7b35f5622a67
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/core/__pycache__/operations.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..73a46078894586e288cc719a5086cf397d62c05e
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_arit.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_arit.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..707006f67c47a7a9df828df0acfa2efd6290d2a3
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_arit.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_exprtools.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_exprtools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8f212c51ac1399949286eed3c4f3c6a584cad38b
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_exprtools.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_logic.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_logic.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ee9654d7f1d29d6265408a8537b54be85e8d110e
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_logic.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_multidimensional.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_multidimensional.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..642f2478dc6a10ab6bf584ed96ed8ebe1b76fc35
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_multidimensional.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_relational.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_relational.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..63ffa080a722f77eba6eb758ad7f69f6913a6a16
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_relational.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_singleton.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_singleton.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4947dd2257733974660ad3e6489d8a0651894db1
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_singleton.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_sympify.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_sympify.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..482050dfcd5e63440e9008779c718a224f399d72
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_sympify.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/geometry/__init__.py b/vllm/lib/python3.10/site-packages/sympy/geometry/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb85d4ff5d53eb44a039a95cfc2fff687322cc76
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/geometry/__init__.py
@@ -0,0 +1,45 @@
+"""
+A geometry module for the SymPy library. This module contains all of the
+entities and functions needed to construct basic geometrical data and to
+perform simple informational queries.
+
+Usage:
+======
+
+Examples
+========
+
+"""
+from sympy.geometry.point import Point, Point2D, Point3D
+from sympy.geometry.line import Line, Ray, Segment, Line2D, Segment2D, Ray2D, \
+ Line3D, Segment3D, Ray3D
+from sympy.geometry.plane import Plane
+from sympy.geometry.ellipse import Ellipse, Circle
+from sympy.geometry.polygon import Polygon, RegularPolygon, Triangle, rad, deg
+from sympy.geometry.util import are_similar, centroid, convex_hull, idiff, \
+ intersection, closest_points, farthest_points
+from sympy.geometry.exceptions import GeometryError
+from sympy.geometry.curve import Curve
+from sympy.geometry.parabola import Parabola
+
+__all__ = [
+ 'Point', 'Point2D', 'Point3D',
+
+ 'Line', 'Ray', 'Segment', 'Line2D', 'Segment2D', 'Ray2D', 'Line3D',
+ 'Segment3D', 'Ray3D',
+
+ 'Plane',
+
+ 'Ellipse', 'Circle',
+
+ 'Polygon', 'RegularPolygon', 'Triangle', 'rad', 'deg',
+
+ 'are_similar', 'centroid', 'convex_hull', 'idiff', 'intersection',
+ 'closest_points', 'farthest_points',
+
+ 'GeometryError',
+
+ 'Curve',
+
+ 'Parabola',
+]
diff --git a/vllm/lib/python3.10/site-packages/sympy/geometry/exceptions.py b/vllm/lib/python3.10/site-packages/sympy/geometry/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..41d97af718de2cebad3accefcd60e43ccf74a3f6
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/geometry/exceptions.py
@@ -0,0 +1,5 @@
+"""Geometry Errors."""
+
+class GeometryError(ValueError):
+ """An exception raised by classes in the geometry module."""
+ pass
diff --git a/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_ellipse.py b/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_ellipse.py
new file mode 100644
index 0000000000000000000000000000000000000000..a79eba8c35771bda9f0980aca68d937f8e625c0a
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_ellipse.py
@@ -0,0 +1,613 @@
+from sympy.core import expand
+from sympy.core.numbers import (Rational, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sec
+from sympy.geometry.line import Segment2D
+from sympy.geometry.point import Point2D
+from sympy.geometry import (Circle, Ellipse, GeometryError, Line, Point,
+ Polygon, Ray, RegularPolygon, Segment,
+ Triangle, intersection)
+from sympy.testing.pytest import raises, slow
+from sympy.integrals.integrals import integrate
+from sympy.functions.special.elliptic_integrals import elliptic_e
+from sympy.functions.elementary.miscellaneous import Max
+
+
+def test_ellipse_equation_using_slope():
+ from sympy.abc import x, y
+
+ e1 = Ellipse(Point(1, 0), 3, 2)
+ assert str(e1.equation(_slope=1)) == str((-x + y + 1)**2/8 + (x + y - 1)**2/18 - 1)
+
+ e2 = Ellipse(Point(0, 0), 4, 1)
+ assert str(e2.equation(_slope=1)) == str((-x + y)**2/2 + (x + y)**2/32 - 1)
+
+ e3 = Ellipse(Point(1, 5), 6, 2)
+ assert str(e3.equation(_slope=2)) == str((-2*x + y - 3)**2/20 + (x + 2*y - 11)**2/180 - 1)
+
+
+def test_object_from_equation():
+ from sympy.abc import x, y, a, b, c, d, e
+ assert Circle(x**2 + y**2 + 3*x + 4*y - 8) == Circle(Point2D(S(-3) / 2, -2), sqrt(57) / 2)
+ assert Circle(x**2 + y**2 + 6*x + 8*y + 25) == Circle(Point2D(-3, -4), 0)
+ assert Circle(a**2 + b**2 + 6*a + 8*b + 25, x='a', y='b') == Circle(Point2D(-3, -4), 0)
+ assert Circle(x**2 + y**2 - 25) == Circle(Point2D(0, 0), 5)
+ assert Circle(x**2 + y**2) == Circle(Point2D(0, 0), 0)
+ assert Circle(a**2 + b**2, x='a', y='b') == Circle(Point2D(0, 0), 0)
+ assert Circle(x**2 + y**2 + 6*x + 8) == Circle(Point2D(-3, 0), 1)
+ assert Circle(x**2 + y**2 + 6*y + 8) == Circle(Point2D(0, -3), 1)
+ assert Circle((x - 1)**2 + y**2 - 9) == Circle(Point2D(1, 0), 3)
+ assert Circle(6*(x**2) + 6*(y**2) + 6*x + 8*y - 25) == Circle(Point2D(Rational(-1, 2), Rational(-2, 3)), 5*sqrt(7)/6)
+ assert Circle(Eq(a**2 + b**2, 25), x='a', y=b) == Circle(Point2D(0, 0), 5)
+ raises(GeometryError, lambda: Circle(x**2 + y**2 + 3*x + 4*y + 26))
+ raises(GeometryError, lambda: Circle(x**2 + y**2 + 25))
+ raises(GeometryError, lambda: Circle(a**2 + b**2 + 25, x='a', y='b'))
+ raises(GeometryError, lambda: Circle(x**2 + 6*y + 8))
+ raises(GeometryError, lambda: Circle(6*(x ** 2) + 4*(y**2) + 6*x + 8*y + 25))
+ raises(ValueError, lambda: Circle(a**2 + b**2 + 3*a + 4*b - 8))
+ # .equation() adds 'real=True' assumption; '==' would fail if assumptions differed
+ x, y = symbols('x y', real=True)
+ eq = a*x**2 + a*y**2 + c*x + d*y + e
+ assert expand(Circle(eq).equation()*a) == eq
+
+
+@slow
+def test_ellipse_geom():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ t = Symbol('t', real=True)
+ y1 = Symbol('y1', real=True)
+ half = S.Half
+ p1 = Point(0, 0)
+ p2 = Point(1, 1)
+ p4 = Point(0, 1)
+
+ e1 = Ellipse(p1, 1, 1)
+ e2 = Ellipse(p2, half, 1)
+ e3 = Ellipse(p1, y1, y1)
+ c1 = Circle(p1, 1)
+ c2 = Circle(p2, 1)
+ c3 = Circle(Point(sqrt(2), sqrt(2)), 1)
+ l1 = Line(p1, p2)
+
+ # Test creation with three points
+ cen, rad = Point(3*half, 2), 5*half
+ assert Circle(Point(0, 0), Point(3, 0), Point(0, 4)) == Circle(cen, rad)
+ assert Circle(Point(0, 0), Point(1, 1), Point(2, 2)) == Segment2D(Point2D(0, 0), Point2D(2, 2))
+
+ raises(ValueError, lambda: Ellipse(None, None, None, 1))
+ raises(ValueError, lambda: Ellipse())
+ raises(GeometryError, lambda: Circle(Point(0, 0)))
+ raises(GeometryError, lambda: Circle(Symbol('x')*Symbol('y')))
+
+ # Basic Stuff
+ assert Ellipse(None, 1, 1).center == Point(0, 0)
+ assert e1 == c1
+ assert e1 != e2
+ assert e1 != l1
+ assert p4 in e1
+ assert e1 in e1
+ assert e2 in e2
+ assert 1 not in e2
+ assert p2 not in e2
+ assert e1.area == pi
+ assert e2.area == pi/2
+ assert e3.area == pi*y1*abs(y1)
+ assert c1.area == e1.area
+ assert c1.circumference == e1.circumference
+ assert e3.circumference == 2*pi*y1
+ assert e1.plot_interval() == e2.plot_interval() == [t, -pi, pi]
+ assert e1.plot_interval(x) == e2.plot_interval(x) == [x, -pi, pi]
+
+ assert c1.minor == 1
+ assert c1.major == 1
+ assert c1.hradius == 1
+ assert c1.vradius == 1
+
+ assert Ellipse((1, 1), 0, 0) == Point(1, 1)
+ assert Ellipse((1, 1), 1, 0) == Segment(Point(0, 1), Point(2, 1))
+ assert Ellipse((1, 1), 0, 1) == Segment(Point(1, 0), Point(1, 2))
+
+ # Private Functions
+ assert hash(c1) == hash(Circle(Point(1, 0), Point(0, 1), Point(0, -1)))
+ assert c1 in e1
+ assert (Line(p1, p2) in e1) is False
+ assert e1.__cmp__(e1) == 0
+ assert e1.__cmp__(Point(0, 0)) > 0
+
+ # Encloses
+ assert e1.encloses(Segment(Point(-0.5, -0.5), Point(0.5, 0.5))) is True
+ assert e1.encloses(Line(p1, p2)) is False
+ assert e1.encloses(Ray(p1, p2)) is False
+ assert e1.encloses(e1) is False
+ assert e1.encloses(
+ Polygon(Point(-0.5, -0.5), Point(-0.5, 0.5), Point(0.5, 0.5))) is True
+ assert e1.encloses(RegularPolygon(p1, 0.5, 3)) is True
+ assert e1.encloses(RegularPolygon(p1, 5, 3)) is False
+ assert e1.encloses(RegularPolygon(p2, 5, 3)) is False
+
+ assert e2.arbitrary_point() in e2
+ raises(ValueError, lambda: Ellipse(Point(x, y), 1, 1).arbitrary_point(parameter='x'))
+
+ # Foci
+ f1, f2 = Point(sqrt(12), 0), Point(-sqrt(12), 0)
+ ef = Ellipse(Point(0, 0), 4, 2)
+ assert ef.foci in [(f1, f2), (f2, f1)]
+
+ # Tangents
+ v = sqrt(2) / 2
+ p1_1 = Point(v, v)
+ p1_2 = p2 + Point(half, 0)
+ p1_3 = p2 + Point(0, 1)
+ assert e1.tangent_lines(p4) == c1.tangent_lines(p4)
+ assert e2.tangent_lines(p1_2) == [Line(Point(Rational(3, 2), 1), Point(Rational(3, 2), S.Half))]
+ assert e2.tangent_lines(p1_3) == [Line(Point(1, 2), Point(Rational(5, 4), 2))]
+ assert c1.tangent_lines(p1_1) != [Line(p1_1, Point(0, sqrt(2)))]
+ assert c1.tangent_lines(p1) == []
+ assert e2.is_tangent(Line(p1_2, p2 + Point(half, 1)))
+ assert e2.is_tangent(Line(p1_3, p2 + Point(half, 1)))
+ assert c1.is_tangent(Line(p1_1, Point(0, sqrt(2))))
+ assert e1.is_tangent(Line(Point(0, 0), Point(1, 1))) is False
+ assert c1.is_tangent(e1) is True
+ assert c1.is_tangent(Ellipse(Point(2, 0), 1, 1)) is True
+ assert c1.is_tangent(
+ Polygon(Point(1, 1), Point(1, -1), Point(2, 0))) is False
+ assert c1.is_tangent(
+ Polygon(Point(1, 1), Point(1, 0), Point(2, 0))) is False
+ assert Circle(Point(5, 5), 3).is_tangent(Circle(Point(0, 5), 1)) is False
+
+ assert Ellipse(Point(5, 5), 2, 1).tangent_lines(Point(0, 0)) == \
+ [Line(Point(0, 0), Point(Rational(77, 25), Rational(132, 25))),
+ Line(Point(0, 0), Point(Rational(33, 5), Rational(22, 5)))]
+ assert Ellipse(Point(5, 5), 2, 1).tangent_lines(Point(3, 4)) == \
+ [Line(Point(3, 4), Point(4, 4)), Line(Point(3, 4), Point(3, 5))]
+ assert Circle(Point(5, 5), 2).tangent_lines(Point(3, 3)) == \
+ [Line(Point(3, 3), Point(4, 3)), Line(Point(3, 3), Point(3, 4))]
+ assert Circle(Point(5, 5), 2).tangent_lines(Point(5 - 2*sqrt(2), 5)) == \
+ [Line(Point(5 - 2*sqrt(2), 5), Point(5 - sqrt(2), 5 - sqrt(2))),
+ Line(Point(5 - 2*sqrt(2), 5), Point(5 - sqrt(2), 5 + sqrt(2))), ]
+ assert Circle(Point(5, 5), 5).tangent_lines(Point(4, 0)) == \
+ [Line(Point(4, 0), Point(Rational(40, 13), Rational(5, 13))),
+ Line(Point(4, 0), Point(5, 0))]
+ assert Circle(Point(5, 5), 5).tangent_lines(Point(0, 6)) == \
+ [Line(Point(0, 6), Point(0, 7)),
+ Line(Point(0, 6), Point(Rational(5, 13), Rational(90, 13)))]
+
+ # for numerical calculations, we shouldn't demand exact equality,
+ # so only test up to the desired precision
+ def lines_close(l1, l2, prec):
+ """ tests whether l1 and 12 are within 10**(-prec)
+ of each other """
+ return abs(l1.p1 - l2.p1) < 10**(-prec) and abs(l1.p2 - l2.p2) < 10**(-prec)
+ def line_list_close(ll1, ll2, prec):
+ return all(lines_close(l1, l2, prec) for l1, l2 in zip(ll1, ll2))
+
+ e = Ellipse(Point(0, 0), 2, 1)
+ assert e.normal_lines(Point(0, 0)) == \
+ [Line(Point(0, 0), Point(0, 1)), Line(Point(0, 0), Point(1, 0))]
+ assert e.normal_lines(Point(1, 0)) == \
+ [Line(Point(0, 0), Point(1, 0))]
+ assert e.normal_lines((0, 1)) == \
+ [Line(Point(0, 0), Point(0, 1))]
+ assert line_list_close(e.normal_lines(Point(1, 1), 2), [
+ Line(Point(Rational(-51, 26), Rational(-1, 5)), Point(Rational(-25, 26), Rational(17, 83))),
+ Line(Point(Rational(28, 29), Rational(-7, 8)), Point(Rational(57, 29), Rational(-9, 2)))], 2)
+ # test the failure of Poly.intervals and checks a point on the boundary
+ p = Point(sqrt(3), S.Half)
+ assert p in e
+ assert line_list_close(e.normal_lines(p, 2), [
+ Line(Point(Rational(-341, 171), Rational(-1, 13)), Point(Rational(-170, 171), Rational(5, 64))),
+ Line(Point(Rational(26, 15), Rational(-1, 2)), Point(Rational(41, 15), Rational(-43, 26)))], 2)
+ # be sure to use the slope that isn't undefined on boundary
+ e = Ellipse((0, 0), 2, 2*sqrt(3)/3)
+ assert line_list_close(e.normal_lines((1, 1), 2), [
+ Line(Point(Rational(-64, 33), Rational(-20, 71)), Point(Rational(-31, 33), Rational(2, 13))),
+ Line(Point(1, -1), Point(2, -4))], 2)
+ # general ellipse fails except under certain conditions
+ e = Ellipse((0, 0), x, 1)
+ assert e.normal_lines((x + 1, 0)) == [Line(Point(0, 0), Point(1, 0))]
+ raises(NotImplementedError, lambda: e.normal_lines((x + 1, 1)))
+ # Properties
+ major = 3
+ minor = 1
+ e4 = Ellipse(p2, minor, major)
+ assert e4.focus_distance == sqrt(major**2 - minor**2)
+ ecc = e4.focus_distance / major
+ assert e4.eccentricity == ecc
+ assert e4.periapsis == major*(1 - ecc)
+ assert e4.apoapsis == major*(1 + ecc)
+ assert e4.semilatus_rectum == major*(1 - ecc ** 2)
+ # independent of orientation
+ e4 = Ellipse(p2, major, minor)
+ assert e4.focus_distance == sqrt(major**2 - minor**2)
+ ecc = e4.focus_distance / major
+ assert e4.eccentricity == ecc
+ assert e4.periapsis == major*(1 - ecc)
+ assert e4.apoapsis == major*(1 + ecc)
+
+ # Intersection
+ l1 = Line(Point(1, -5), Point(1, 5))
+ l2 = Line(Point(-5, -1), Point(5, -1))
+ l3 = Line(Point(-1, -1), Point(1, 1))
+ l4 = Line(Point(-10, 0), Point(0, 10))
+ pts_c1_l3 = [Point(sqrt(2)/2, sqrt(2)/2), Point(-sqrt(2)/2, -sqrt(2)/2)]
+
+ assert intersection(e2, l4) == []
+ assert intersection(c1, Point(1, 0)) == [Point(1, 0)]
+ assert intersection(c1, l1) == [Point(1, 0)]
+ assert intersection(c1, l2) == [Point(0, -1)]
+ assert intersection(c1, l3) in [pts_c1_l3, [pts_c1_l3[1], pts_c1_l3[0]]]
+ assert intersection(c1, c2) == [Point(0, 1), Point(1, 0)]
+ assert intersection(c1, c3) == [Point(sqrt(2)/2, sqrt(2)/2)]
+ assert e1.intersection(l1) == [Point(1, 0)]
+ assert e2.intersection(l4) == []
+ assert e1.intersection(Circle(Point(0, 2), 1)) == [Point(0, 1)]
+ assert e1.intersection(Circle(Point(5, 0), 1)) == []
+ assert e1.intersection(Ellipse(Point(2, 0), 1, 1)) == [Point(1, 0)]
+ assert e1.intersection(Ellipse(Point(5, 0), 1, 1)) == []
+ assert e1.intersection(Point(2, 0)) == []
+ assert e1.intersection(e1) == e1
+ assert intersection(Ellipse(Point(0, 0), 2, 1), Ellipse(Point(3, 0), 1, 2)) == [Point(2, 0)]
+ assert intersection(Circle(Point(0, 0), 2), Circle(Point(3, 0), 1)) == [Point(2, 0)]
+ assert intersection(Circle(Point(0, 0), 2), Circle(Point(7, 0), 1)) == []
+ assert intersection(Ellipse(Point(0, 0), 5, 17), Ellipse(Point(4, 0), 1, 0.2)
+ ) == [Point(5.0, 0, evaluate=False)]
+ assert intersection(Ellipse(Point(0, 0), 5, 17), Ellipse(Point(4, 0), 0.999, 0.2)) == []
+ assert Circle((0, 0), S.Half).intersection(
+ Triangle((-1, 0), (1, 0), (0, 1))) == [
+ Point(Rational(-1, 2), 0), Point(S.Half, 0)]
+ raises(TypeError, lambda: intersection(e2, Line((0, 0, 0), (0, 0, 1))))
+ raises(TypeError, lambda: intersection(e2, Rational(12)))
+ raises(TypeError, lambda: Ellipse.intersection(e2, 1))
+ # some special case intersections
+ csmall = Circle(p1, 3)
+ cbig = Circle(p1, 5)
+ cout = Circle(Point(5, 5), 1)
+ # one circle inside of another
+ assert csmall.intersection(cbig) == []
+ # separate circles
+ assert csmall.intersection(cout) == []
+ # coincident circles
+ assert csmall.intersection(csmall) == csmall
+
+ v = sqrt(2)
+ t1 = Triangle(Point(0, v), Point(0, -v), Point(v, 0))
+ points = intersection(t1, c1)
+ assert len(points) == 4
+ assert Point(0, 1) in points
+ assert Point(0, -1) in points
+ assert Point(v/2, v/2) in points
+ assert Point(v/2, -v/2) in points
+
+ circ = Circle(Point(0, 0), 5)
+ elip = Ellipse(Point(0, 0), 5, 20)
+ assert intersection(circ, elip) in \
+ [[Point(5, 0), Point(-5, 0)], [Point(-5, 0), Point(5, 0)]]
+ assert elip.tangent_lines(Point(0, 0)) == []
+ elip = Ellipse(Point(0, 0), 3, 2)
+ assert elip.tangent_lines(Point(3, 0)) == \
+ [Line(Point(3, 0), Point(3, -12))]
+
+ e1 = Ellipse(Point(0, 0), 5, 10)
+ e2 = Ellipse(Point(2, 1), 4, 8)
+ a = Rational(53, 17)
+ c = 2*sqrt(3991)/17
+ ans = [Point(a - c/8, a/2 + c), Point(a + c/8, a/2 - c)]
+ assert e1.intersection(e2) == ans
+ e2 = Ellipse(Point(x, y), 4, 8)
+ c = sqrt(3991)
+ ans = [Point(-c/68 + a, c*Rational(2, 17) + a/2), Point(c/68 + a, c*Rational(-2, 17) + a/2)]
+ assert [p.subs({x: 2, y:1}) for p in e1.intersection(e2)] == ans
+
+ # Combinations of above
+ assert e3.is_tangent(e3.tangent_lines(p1 + Point(y1, 0))[0])
+
+ e = Ellipse((1, 2), 3, 2)
+ assert e.tangent_lines(Point(10, 0)) == \
+ [Line(Point(10, 0), Point(1, 0)),
+ Line(Point(10, 0), Point(Rational(14, 5), Rational(18, 5)))]
+
+ # encloses_point
+ e = Ellipse((0, 0), 1, 2)
+ assert e.encloses_point(e.center)
+ assert e.encloses_point(e.center + Point(0, e.vradius - Rational(1, 10)))
+ assert e.encloses_point(e.center + Point(e.hradius - Rational(1, 10), 0))
+ assert e.encloses_point(e.center + Point(e.hradius, 0)) is False
+ assert e.encloses_point(
+ e.center + Point(e.hradius + Rational(1, 10), 0)) is False
+ e = Ellipse((0, 0), 2, 1)
+ assert e.encloses_point(e.center)
+ assert e.encloses_point(e.center + Point(0, e.vradius - Rational(1, 10)))
+ assert e.encloses_point(e.center + Point(e.hradius - Rational(1, 10), 0))
+ assert e.encloses_point(e.center + Point(e.hradius, 0)) is False
+ assert e.encloses_point(
+ e.center + Point(e.hradius + Rational(1, 10), 0)) is False
+ assert c1.encloses_point(Point(1, 0)) is False
+ assert c1.encloses_point(Point(0.3, 0.4)) is True
+
+ assert e.scale(2, 3) == Ellipse((0, 0), 4, 3)
+ assert e.scale(3, 6) == Ellipse((0, 0), 6, 6)
+ assert e.rotate(pi) == e
+ assert e.rotate(pi, (1, 2)) == Ellipse(Point(2, 4), 2, 1)
+ raises(NotImplementedError, lambda: e.rotate(pi/3))
+
+ # Circle rotation tests (Issue #11743)
+ # Link - https://github.com/sympy/sympy/issues/11743
+ cir = Circle(Point(1, 0), 1)
+ assert cir.rotate(pi/2) == Circle(Point(0, 1), 1)
+ assert cir.rotate(pi/3) == Circle(Point(S.Half, sqrt(3)/2), 1)
+ assert cir.rotate(pi/3, Point(1, 0)) == Circle(Point(1, 0), 1)
+ assert cir.rotate(pi/3, Point(0, 1)) == Circle(Point(S.Half + sqrt(3)/2, S.Half + sqrt(3)/2), 1)
+
+
+def test_construction():
+ e1 = Ellipse(hradius=2, vradius=1, eccentricity=None)
+ assert e1.eccentricity == sqrt(3)/2
+
+ e2 = Ellipse(hradius=2, vradius=None, eccentricity=sqrt(3)/2)
+ assert e2.vradius == 1
+
+ e3 = Ellipse(hradius=None, vradius=1, eccentricity=sqrt(3)/2)
+ assert e3.hradius == 2
+
+ # filter(None, iterator) filters out anything falsey, including 0
+ # eccentricity would be filtered out in this case and the constructor would throw an error
+ e4 = Ellipse(Point(0, 0), hradius=1, eccentricity=0)
+ assert e4.vradius == 1
+
+ #tests for eccentricity > 1
+ raises(GeometryError, lambda: Ellipse(Point(3, 1), hradius=3, eccentricity = S(3)/2))
+ raises(GeometryError, lambda: Ellipse(Point(3, 1), hradius=3, eccentricity=sec(5)))
+ raises(GeometryError, lambda: Ellipse(Point(3, 1), hradius=3, eccentricity=S.Pi-S(2)))
+
+ #tests for eccentricity = 1
+ #if vradius is not defined
+ assert Ellipse(None, 1, None, 1).length == 2
+ #if hradius is not defined
+ raises(GeometryError, lambda: Ellipse(None, None, 1, eccentricity = 1))
+
+ #tests for eccentricity < 0
+ raises(GeometryError, lambda: Ellipse(Point(3, 1), hradius=3, eccentricity = -3))
+ raises(GeometryError, lambda: Ellipse(Point(3, 1), hradius=3, eccentricity = -0.5))
+
+def test_ellipse_random_point():
+ y1 = Symbol('y1', real=True)
+ e3 = Ellipse(Point(0, 0), y1, y1)
+ rx, ry = Symbol('rx'), Symbol('ry')
+ for ind in range(0, 5):
+ r = e3.random_point()
+ # substitution should give zero*y1**2
+ assert e3.equation(rx, ry).subs(zip((rx, ry), r.args)).equals(0)
+ # test for the case with seed
+ r = e3.random_point(seed=1)
+ assert e3.equation(rx, ry).subs(zip((rx, ry), r.args)).equals(0)
+
+
+def test_repr():
+ assert repr(Circle((0, 1), 2)) == 'Circle(Point2D(0, 1), 2)'
+
+
+def test_transform():
+ c = Circle((1, 1), 2)
+ assert c.scale(-1) == Circle((-1, 1), 2)
+ assert c.scale(y=-1) == Circle((1, -1), 2)
+ assert c.scale(2) == Ellipse((2, 1), 4, 2)
+
+ assert Ellipse((0, 0), 2, 3).scale(2, 3, (4, 5)) == \
+ Ellipse(Point(-4, -10), 4, 9)
+ assert Circle((0, 0), 2).scale(2, 3, (4, 5)) == \
+ Ellipse(Point(-4, -10), 4, 6)
+ assert Ellipse((0, 0), 2, 3).scale(3, 3, (4, 5)) == \
+ Ellipse(Point(-8, -10), 6, 9)
+ assert Circle((0, 0), 2).scale(3, 3, (4, 5)) == \
+ Circle(Point(-8, -10), 6)
+ assert Circle(Point(-8, -10), 6).scale(Rational(1, 3), Rational(1, 3), (4, 5)) == \
+ Circle((0, 0), 2)
+ assert Circle((0, 0), 2).translate(4, 5) == \
+ Circle((4, 5), 2)
+ assert Circle((0, 0), 2).scale(3, 3) == \
+ Circle((0, 0), 6)
+
+
+def test_bounds():
+ e1 = Ellipse(Point(0, 0), 3, 5)
+ e2 = Ellipse(Point(2, -2), 7, 7)
+ c1 = Circle(Point(2, -2), 7)
+ c2 = Circle(Point(-2, 0), Point(0, 2), Point(2, 0))
+ assert e1.bounds == (-3, -5, 3, 5)
+ assert e2.bounds == (-5, -9, 9, 5)
+ assert c1.bounds == (-5, -9, 9, 5)
+ assert c2.bounds == (-2, -2, 2, 2)
+
+
+def test_reflect():
+ b = Symbol('b')
+ m = Symbol('m')
+ l = Line((0, b), slope=m)
+ t1 = Triangle((0, 0), (1, 0), (2, 3))
+ assert t1.area == -t1.reflect(l).area
+ e = Ellipse((1, 0), 1, 2)
+ assert e.area == -e.reflect(Line((1, 0), slope=0)).area
+ assert e.area == -e.reflect(Line((1, 0), slope=oo)).area
+ raises(NotImplementedError, lambda: e.reflect(Line((1, 0), slope=m)))
+ assert Circle((0, 1), 1).reflect(Line((0, 0), (1, 1))) == Circle(Point2D(1, 0), -1)
+
+
+def test_is_tangent():
+ e1 = Ellipse(Point(0, 0), 3, 5)
+ c1 = Circle(Point(2, -2), 7)
+ assert e1.is_tangent(Point(0, 0)) is False
+ assert e1.is_tangent(Point(3, 0)) is False
+ assert e1.is_tangent(e1) is True
+ assert e1.is_tangent(Ellipse((0, 0), 1, 2)) is False
+ assert e1.is_tangent(Ellipse((0, 0), 3, 2)) is True
+ assert c1.is_tangent(Ellipse((2, -2), 7, 1)) is True
+ assert c1.is_tangent(Circle((11, -2), 2)) is True
+ assert c1.is_tangent(Circle((7, -2), 2)) is True
+ assert c1.is_tangent(Ray((-5, -2), (-15, -20))) is False
+ assert c1.is_tangent(Ray((-3, -2), (-15, -20))) is False
+ assert c1.is_tangent(Ray((-3, -22), (15, 20))) is False
+ assert c1.is_tangent(Ray((9, 20), (9, -20))) is True
+ assert c1.is_tangent(Ray((2, 5), (9, 5))) is True
+ assert c1.is_tangent(Segment((2, 5), (9, 5))) is True
+ assert e1.is_tangent(Segment((2, 2), (-7, 7))) is False
+ assert e1.is_tangent(Segment((0, 0), (1, 2))) is False
+ assert c1.is_tangent(Segment((0, 0), (-5, -2))) is False
+ assert e1.is_tangent(Segment((3, 0), (12, 12))) is False
+ assert e1.is_tangent(Segment((12, 12), (3, 0))) is False
+ assert e1.is_tangent(Segment((-3, 0), (3, 0))) is False
+ assert e1.is_tangent(Segment((-3, 5), (3, 5))) is True
+ assert e1.is_tangent(Line((10, 0), (10, 10))) is False
+ assert e1.is_tangent(Line((0, 0), (1, 1))) is False
+ assert e1.is_tangent(Line((-3, 0), (-2.99, -0.001))) is False
+ assert e1.is_tangent(Line((-3, 0), (-3, 1))) is True
+ assert e1.is_tangent(Polygon((0, 0), (5, 5), (5, -5))) is False
+ assert e1.is_tangent(Polygon((-100, -50), (-40, -334), (-70, -52))) is False
+ assert e1.is_tangent(Polygon((-3, 0), (3, 0), (0, 1))) is False
+ assert e1.is_tangent(Polygon((-3, 0), (3, 0), (0, 5))) is False
+ assert e1.is_tangent(Polygon((-3, 0), (0, -5), (3, 0), (0, 5))) is False
+ assert e1.is_tangent(Polygon((-3, -5), (-3, 5), (3, 5), (3, -5))) is True
+ assert c1.is_tangent(Polygon((-3, -5), (-3, 5), (3, 5), (3, -5))) is False
+ assert e1.is_tangent(Polygon((0, 0), (3, 0), (7, 7), (0, 5))) is False
+ assert e1.is_tangent(Polygon((3, 12), (3, -12), (6, 5))) is False
+ assert e1.is_tangent(Polygon((3, 12), (3, -12), (0, -5), (0, 5))) is False
+ assert e1.is_tangent(Polygon((3, 0), (5, 7), (6, -5))) is False
+ assert c1.is_tangent(Segment((0, 0), (-5, -2))) is False
+ assert e1.is_tangent(Segment((-3, 0), (3, 0))) is False
+ assert e1.is_tangent(Segment((-3, 5), (3, 5))) is True
+ assert e1.is_tangent(Polygon((0, 0), (5, 5), (5, -5))) is False
+ assert e1.is_tangent(Polygon((-100, -50), (-40, -334), (-70, -52))) is False
+ assert e1.is_tangent(Polygon((-3, -5), (-3, 5), (3, 5), (3, -5))) is True
+ assert c1.is_tangent(Polygon((-3, -5), (-3, 5), (3, 5), (3, -5))) is False
+ assert e1.is_tangent(Polygon((3, 12), (3, -12), (0, -5), (0, 5))) is False
+ assert e1.is_tangent(Polygon((3, 0), (5, 7), (6, -5))) is False
+ raises(TypeError, lambda: e1.is_tangent(Point(0, 0, 0)))
+ raises(TypeError, lambda: e1.is_tangent(Rational(5)))
+
+
+def test_parameter_value():
+ t = Symbol('t')
+ e = Ellipse(Point(0, 0), 3, 5)
+ assert e.parameter_value((3, 0), t) == {t: 0}
+ raises(ValueError, lambda: e.parameter_value((4, 0), t))
+
+
+@slow
+def test_second_moment_of_area():
+ x, y = symbols('x, y')
+ e = Ellipse(Point(0, 0), 5, 4)
+ I_yy = 2*4*integrate(sqrt(25 - x**2)*x**2, (x, -5, 5))/5
+ I_xx = 2*5*integrate(sqrt(16 - y**2)*y**2, (y, -4, 4))/4
+ Y = 3*sqrt(1 - x**2/5**2)
+ I_xy = integrate(integrate(y, (y, -Y, Y))*x, (x, -5, 5))
+ assert I_yy == e.second_moment_of_area()[1]
+ assert I_xx == e.second_moment_of_area()[0]
+ assert I_xy == e.second_moment_of_area()[2]
+ #checking for other point
+ t1 = e.second_moment_of_area(Point(6,5))
+ t2 = (580*pi, 845*pi, 600*pi)
+ assert t1==t2
+
+
+def test_section_modulus_and_polar_second_moment_of_area():
+ d = Symbol('d', positive=True)
+ c = Circle((3, 7), 8)
+ assert c.polar_second_moment_of_area() == 2048*pi
+ assert c.section_modulus() == (128*pi, 128*pi)
+ c = Circle((2, 9), d/2)
+ assert c.polar_second_moment_of_area() == pi*d**3*Abs(d)/64 + pi*d*Abs(d)**3/64
+ assert c.section_modulus() == (pi*d**3/S(32), pi*d**3/S(32))
+
+ a, b = symbols('a, b', positive=True)
+ e = Ellipse((4, 6), a, b)
+ assert e.section_modulus() == (pi*a*b**2/S(4), pi*a**2*b/S(4))
+ assert e.polar_second_moment_of_area() == pi*a**3*b/S(4) + pi*a*b**3/S(4)
+ e = e.rotate(pi/2) # no change in polar and section modulus
+ assert e.section_modulus() == (pi*a**2*b/S(4), pi*a*b**2/S(4))
+ assert e.polar_second_moment_of_area() == pi*a**3*b/S(4) + pi*a*b**3/S(4)
+
+ e = Ellipse((a, b), 2, 6)
+ assert e.section_modulus() == (18*pi, 6*pi)
+ assert e.polar_second_moment_of_area() == 120*pi
+
+ e = Ellipse(Point(0, 0), 2, 2)
+ assert e.section_modulus() == (2*pi, 2*pi)
+ assert e.section_modulus(Point(2, 2)) == (2*pi, 2*pi)
+ assert e.section_modulus((2, 2)) == (2*pi, 2*pi)
+
+
+def test_circumference():
+ M = Symbol('M')
+ m = Symbol('m')
+ assert Ellipse(Point(0, 0), M, m).circumference == 4 * M * elliptic_e((M ** 2 - m ** 2) / M**2)
+
+ assert Ellipse(Point(0, 0), 5, 4).circumference == 20 * elliptic_e(S(9) / 25)
+
+ # circle
+ assert Ellipse(None, 1, None, 0).circumference == 2*pi
+
+ # test numerically
+ assert abs(Ellipse(None, hradius=5, vradius=3).circumference.evalf(16) - 25.52699886339813) < 1e-10
+
+
+def test_issue_15259():
+ assert Circle((1, 2), 0) == Point(1, 2)
+
+
+def test_issue_15797_equals():
+ Ri = 0.024127189424130748
+ Ci = (0.0864931002830291, 0.0819863295239654)
+ A = Point(0, 0.0578591400998346)
+ c = Circle(Ci, Ri) # evaluated
+ assert c.is_tangent(c.tangent_lines(A)[0]) == True
+ assert c.center.x.is_Rational
+ assert c.center.y.is_Rational
+ assert c.radius.is_Rational
+ u = Circle(Ci, Ri, evaluate=False) # unevaluated
+ assert u.center.x.is_Float
+ assert u.center.y.is_Float
+ assert u.radius.is_Float
+
+
+def test_auxiliary_circle():
+ x, y, a, b = symbols('x y a b')
+ e = Ellipse((x, y), a, b)
+ # the general result
+ assert e.auxiliary_circle() == Circle((x, y), Max(a, b))
+ # a special case where Ellipse is a Circle
+ assert Circle((3, 4), 8).auxiliary_circle() == Circle((3, 4), 8)
+
+
+def test_director_circle():
+ x, y, a, b = symbols('x y a b')
+ e = Ellipse((x, y), a, b)
+ # the general result
+ assert e.director_circle() == Circle((x, y), sqrt(a**2 + b**2))
+ # a special case where Ellipse is a Circle
+ assert Circle((3, 4), 8).director_circle() == Circle((3, 4), 8*sqrt(2))
+
+
+def test_evolute():
+ #ellipse centered at h,k
+ x, y, h, k = symbols('x y h k',real = True)
+ a, b = symbols('a b')
+ e = Ellipse(Point(h, k), a, b)
+ t1 = (e.hradius*(x - e.center.x))**Rational(2, 3)
+ t2 = (e.vradius*(y - e.center.y))**Rational(2, 3)
+ E = t1 + t2 - (e.hradius**2 - e.vradius**2)**Rational(2, 3)
+ assert e.evolute() == E
+ #Numerical Example
+ e = Ellipse(Point(1, 1), 6, 3)
+ t1 = (6*(x - 1))**Rational(2, 3)
+ t2 = (3*(y - 1))**Rational(2, 3)
+ E = t1 + t2 - (27)**Rational(2, 3)
+ assert e.evolute() == E
+
+
+def test_svg():
+ e1 = Ellipse(Point(1, 0), 3, 2)
+ assert e1._svg(2, "#FFAAFF") == ''
diff --git a/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_entity.py b/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_entity.py
new file mode 100644
index 0000000000000000000000000000000000000000..cecfdb785506d1b2f4ef496703c430794f09e589
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_entity.py
@@ -0,0 +1,120 @@
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.geometry import (Circle, Ellipse, Point, Line, Parabola,
+ Polygon, Ray, RegularPolygon, Segment, Triangle, Plane, Curve)
+from sympy.geometry.entity import scale, GeometryEntity
+from sympy.testing.pytest import raises
+
+
+def test_entity():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+
+ assert GeometryEntity(x, y) in GeometryEntity(x, y)
+ raises(NotImplementedError, lambda: Point(0, 0) in GeometryEntity(x, y))
+
+ assert GeometryEntity(x, y) == GeometryEntity(x, y)
+ assert GeometryEntity(x, y).equals(GeometryEntity(x, y))
+
+ c = Circle((0, 0), 5)
+ assert GeometryEntity.encloses(c, Point(0, 0))
+ assert GeometryEntity.encloses(c, Segment((0, 0), (1, 1)))
+ assert GeometryEntity.encloses(c, Line((0, 0), (1, 1))) is False
+ assert GeometryEntity.encloses(c, Circle((0, 0), 4))
+ assert GeometryEntity.encloses(c, Polygon(Point(0, 0), Point(1, 0), Point(0, 1)))
+ assert GeometryEntity.encloses(c, RegularPolygon(Point(8, 8), 1, 3)) is False
+
+
+def test_svg():
+ a = Symbol('a')
+ b = Symbol('b')
+ d = Symbol('d')
+
+ entity = Circle(Point(a, b), d)
+ assert entity._repr_svg_() is None
+
+ entity = Circle(Point(0, 0), S.Infinity)
+ assert entity._repr_svg_() is None
+
+
+def test_subs():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ p = Point(x, 2)
+ q = Point(1, 1)
+ r = Point(3, 4)
+ for o in [p,
+ Segment(p, q),
+ Ray(p, q),
+ Line(p, q),
+ Triangle(p, q, r),
+ RegularPolygon(p, 3, 6),
+ Polygon(p, q, r, Point(5, 4)),
+ Circle(p, 3),
+ Ellipse(p, 3, 4)]:
+ assert 'y' in str(o.subs(x, y))
+ assert p.subs({x: 1}) == Point(1, 2)
+ assert Point(1, 2).subs(Point(1, 2), Point(3, 4)) == Point(3, 4)
+ assert Point(1, 2).subs((1, 2), Point(3, 4)) == Point(3, 4)
+ assert Point(1, 2).subs(Point(1, 2), Point(3, 4)) == Point(3, 4)
+ assert Point(1, 2).subs({(1, 2)}) == Point(2, 2)
+ raises(ValueError, lambda: Point(1, 2).subs(1))
+ raises(ValueError, lambda: Point(1, 1).subs((Point(1, 1), Point(1,
+ 2)), 1, 2))
+
+
+def test_transform():
+ assert scale(1, 2, (3, 4)).tolist() == \
+ [[1, 0, 0], [0, 2, 0], [0, -4, 1]]
+
+
+def test_reflect_entity_overrides():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ b = Symbol('b')
+ m = Symbol('m')
+ l = Line((0, b), slope=m)
+ p = Point(x, y)
+ r = p.reflect(l)
+ c = Circle((x, y), 3)
+ cr = c.reflect(l)
+ assert cr == Circle(r, -3)
+ assert c.area == -cr.area
+
+ pent = RegularPolygon((1, 2), 1, 5)
+ slope = S.ComplexInfinity
+ while slope is S.ComplexInfinity:
+ slope = Rational(*(x._random()/2).as_real_imag())
+ l = Line(pent.vertices[1], slope=slope)
+ rpent = pent.reflect(l)
+ assert rpent.center == pent.center.reflect(l)
+ rvert = [i.reflect(l) for i in pent.vertices]
+ for v in rpent.vertices:
+ for i in range(len(rvert)):
+ ri = rvert[i]
+ if ri.equals(v):
+ rvert.remove(ri)
+ break
+ assert not rvert
+ assert pent.area.equals(-rpent.area)
+
+
+def test_geometry_EvalfMixin():
+ x = pi
+ t = Symbol('t')
+ for g in [
+ Point(x, x),
+ Plane(Point(0, x, 0), (0, 0, x)),
+ Curve((x*t, x), (t, 0, x)),
+ Ellipse((x, x), x, -x),
+ Circle((x, x), x),
+ Line((0, x), (x, 0)),
+ Segment((0, x), (x, 0)),
+ Ray((0, x), (x, 0)),
+ Parabola((0, x), Line((-x, 0), (x, 0))),
+ Polygon((0, 0), (0, x), (x, 0), (x, x)),
+ RegularPolygon((0, x), x, 4, x),
+ Triangle((0, 0), (x, 0), (x, x)),
+ ]:
+ assert str(g).replace('pi', '3.1') == str(g.n(2))
diff --git a/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_geometrysets.py b/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_geometrysets.py
new file mode 100644
index 0000000000000000000000000000000000000000..c52898b3c9ba4e9db80c244db3aebf88db2cc8b4
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_geometrysets.py
@@ -0,0 +1,38 @@
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.geometry import Circle, Line, Point, Polygon, Segment
+from sympy.sets import FiniteSet, Union, Intersection, EmptySet
+
+
+def test_booleans():
+ """ test basic unions and intersections """
+ half = S.Half
+
+ p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+ p5, p6, p7 = map(Point, [(3, 2), (1, -1), (0, 2)])
+ l1 = Line(Point(0,0), Point(1,1))
+ l2 = Line(Point(half, half), Point(5,5))
+ l3 = Line(p2, p3)
+ l4 = Line(p3, p4)
+ poly1 = Polygon(p1, p2, p3, p4)
+ poly2 = Polygon(p5, p6, p7)
+ poly3 = Polygon(p1, p2, p5)
+ assert Union(l1, l2).equals(l1)
+ assert Intersection(l1, l2).equals(l1)
+ assert Intersection(l1, l4) == FiniteSet(Point(1,1))
+ assert Intersection(Union(l1, l4), l3) == FiniteSet(Point(Rational(-1, 3), Rational(-1, 3)), Point(5, 1))
+ assert Intersection(l1, FiniteSet(Point(7,-7))) == EmptySet
+ assert Intersection(Circle(Point(0,0), 3), Line(p1,p2)) == FiniteSet(Point(-3,0), Point(3,0))
+ assert Intersection(l1, FiniteSet(p1)) == FiniteSet(p1)
+ assert Union(l1, FiniteSet(p1)) == l1
+
+ fs = FiniteSet(Point(Rational(1, 3), 1), Point(Rational(2, 3), 0), Point(Rational(9, 5), Rational(1, 5)), Point(Rational(7, 3), 1))
+ # test the intersection of polygons
+ assert Intersection(poly1, poly2) == fs
+ # make sure if we union polygons with subsets, the subsets go away
+ assert Union(poly1, poly2, fs) == Union(poly1, poly2)
+ # make sure that if we union with a FiniteSet that isn't a subset,
+ # that the points in the intersection stop being listed
+ assert Union(poly1, FiniteSet(Point(0,0), Point(3,5))) == Union(poly1, FiniteSet(Point(3,5)))
+ # intersect two polygons that share an edge
+ assert Intersection(poly1, poly3) == Union(FiniteSet(Point(Rational(3, 2), 1), Point(2, 1)), Segment(Point(0, 0), Point(1, 0)))
diff --git a/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_point.py b/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_point.py
new file mode 100644
index 0000000000000000000000000000000000000000..abe63874a84ea9426c31bdd517b9282b779cc52b
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_point.py
@@ -0,0 +1,481 @@
+from sympy.core.basic import Basic
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.parameters import evaluate
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.geometry import Line, Point, Point2D, Point3D, Line3D, Plane
+from sympy.geometry.entity import rotate, scale, translate, GeometryEntity
+from sympy.matrices import Matrix
+from sympy.utilities.iterables import subsets, permutations, cartes
+from sympy.utilities.misc import Undecidable
+from sympy.testing.pytest import raises, warns
+
+
+def test_point():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ x1 = Symbol('x1', real=True)
+ x2 = Symbol('x2', real=True)
+ y1 = Symbol('y1', real=True)
+ y2 = Symbol('y2', real=True)
+ half = S.Half
+ p1 = Point(x1, x2)
+ p2 = Point(y1, y2)
+ p3 = Point(0, 0)
+ p4 = Point(1, 1)
+ p5 = Point(0, 1)
+ line = Line(Point(1, 0), slope=1)
+
+ assert p1 in p1
+ assert p1 not in p2
+ assert p2.y == y2
+ assert (p3 + p4) == p4
+ assert (p2 - p1) == Point(y1 - x1, y2 - x2)
+ assert -p2 == Point(-y1, -y2)
+ raises(TypeError, lambda: Point(1))
+ raises(ValueError, lambda: Point([1]))
+ raises(ValueError, lambda: Point(3, I))
+ raises(ValueError, lambda: Point(2*I, I))
+ raises(ValueError, lambda: Point(3 + I, I))
+
+ assert Point(34.05, sqrt(3)) == Point(Rational(681, 20), sqrt(3))
+ assert Point.midpoint(p3, p4) == Point(half, half)
+ assert Point.midpoint(p1, p4) == Point(half + half*x1, half + half*x2)
+ assert Point.midpoint(p2, p2) == p2
+ assert p2.midpoint(p2) == p2
+ assert p1.origin == Point(0, 0)
+
+ assert Point.distance(p3, p4) == sqrt(2)
+ assert Point.distance(p1, p1) == 0
+ assert Point.distance(p3, p2) == sqrt(p2.x**2 + p2.y**2)
+ raises(TypeError, lambda: Point.distance(p1, 0))
+ raises(TypeError, lambda: Point.distance(p1, GeometryEntity()))
+
+ # distance should be symmetric
+ assert p1.distance(line) == line.distance(p1)
+ assert p4.distance(line) == line.distance(p4)
+
+ assert Point.taxicab_distance(p4, p3) == 2
+
+ assert Point.canberra_distance(p4, p5) == 1
+ raises(ValueError, lambda: Point.canberra_distance(p3, p3))
+
+ p1_1 = Point(x1, x1)
+ p1_2 = Point(y2, y2)
+ p1_3 = Point(x1 + 1, x1)
+ assert Point.is_collinear(p3)
+
+ with warns(UserWarning, test_stacklevel=False):
+ assert Point.is_collinear(p3, Point(p3, dim=4))
+ assert p3.is_collinear()
+ assert Point.is_collinear(p3, p4)
+ assert Point.is_collinear(p3, p4, p1_1, p1_2)
+ assert Point.is_collinear(p3, p4, p1_1, p1_3) is False
+ assert Point.is_collinear(p3, p3, p4, p5) is False
+
+ raises(TypeError, lambda: Point.is_collinear(line))
+ raises(TypeError, lambda: p1_1.is_collinear(line))
+
+ assert p3.intersection(Point(0, 0)) == [p3]
+ assert p3.intersection(p4) == []
+ assert p3.intersection(line) == []
+ with warns(UserWarning, test_stacklevel=False):
+ assert Point.intersection(Point(0, 0, 0), Point(0, 0)) == [Point(0, 0, 0)]
+
+ x_pos = Symbol('x', positive=True)
+ p2_1 = Point(x_pos, 0)
+ p2_2 = Point(0, x_pos)
+ p2_3 = Point(-x_pos, 0)
+ p2_4 = Point(0, -x_pos)
+ p2_5 = Point(x_pos, 5)
+ assert Point.is_concyclic(p2_1)
+ assert Point.is_concyclic(p2_1, p2_2)
+ assert Point.is_concyclic(p2_1, p2_2, p2_3, p2_4)
+ for pts in permutations((p2_1, p2_2, p2_3, p2_5)):
+ assert Point.is_concyclic(*pts) is False
+ assert Point.is_concyclic(p4, p4 * 2, p4 * 3) is False
+ assert Point(0, 0).is_concyclic((1, 1), (2, 2), (2, 1)) is False
+ assert Point.is_concyclic(Point(0, 0, 0, 0), Point(1, 0, 0, 0), Point(1, 1, 0, 0), Point(1, 1, 1, 0)) is False
+
+ assert p1.is_scalar_multiple(p1)
+ assert p1.is_scalar_multiple(2*p1)
+ assert not p1.is_scalar_multiple(p2)
+ assert Point.is_scalar_multiple(Point(1, 1), (-1, -1))
+ assert Point.is_scalar_multiple(Point(0, 0), (0, -1))
+ # test when is_scalar_multiple can't be determined
+ raises(Undecidable, lambda: Point.is_scalar_multiple(Point(sympify("x1%y1"), sympify("x2%y2")), Point(0, 1)))
+
+ assert Point(0, 1).orthogonal_direction == Point(1, 0)
+ assert Point(1, 0).orthogonal_direction == Point(0, 1)
+
+ assert p1.is_zero is None
+ assert p3.is_zero
+ assert p4.is_zero is False
+ assert p1.is_nonzero is None
+ assert p3.is_nonzero is False
+ assert p4.is_nonzero
+
+ assert p4.scale(2, 3) == Point(2, 3)
+ assert p3.scale(2, 3) == p3
+
+ assert p4.rotate(pi, Point(0.5, 0.5)) == p3
+ assert p1.__radd__(p2) == p1.midpoint(p2).scale(2, 2)
+ assert (-p3).__rsub__(p4) == p3.midpoint(p4).scale(2, 2)
+
+ assert p4 * 5 == Point(5, 5)
+ assert p4 / 5 == Point(0.2, 0.2)
+ assert 5 * p4 == Point(5, 5)
+
+ raises(ValueError, lambda: Point(0, 0) + 10)
+
+ # Point differences should be simplified
+ assert Point(x*(x - 1), y) - Point(x**2 - x, y + 1) == Point(0, -1)
+
+ a, b = S.Half, Rational(1, 3)
+ assert Point(a, b).evalf(2) == \
+ Point(a.n(2), b.n(2), evaluate=False)
+ raises(ValueError, lambda: Point(1, 2) + 1)
+
+ # test project
+ assert Point.project((0, 1), (1, 0)) == Point(0, 0)
+ assert Point.project((1, 1), (1, 0)) == Point(1, 0)
+ raises(ValueError, lambda: Point.project(p1, Point(0, 0)))
+
+ # test transformations
+ p = Point(1, 0)
+ assert p.rotate(pi/2) == Point(0, 1)
+ assert p.rotate(pi/2, p) == p
+ p = Point(1, 1)
+ assert p.scale(2, 3) == Point(2, 3)
+ assert p.translate(1, 2) == Point(2, 3)
+ assert p.translate(1) == Point(2, 1)
+ assert p.translate(y=1) == Point(1, 2)
+ assert p.translate(*p.args) == Point(2, 2)
+
+ # Check invalid input for transform
+ raises(ValueError, lambda: p3.transform(p3))
+ raises(ValueError, lambda: p.transform(Matrix([[1, 0], [0, 1]])))
+
+ # test __contains__
+ assert 0 in Point(0, 0, 0, 0)
+ assert 1 not in Point(0, 0, 0, 0)
+
+ # test affine_rank
+ assert Point.affine_rank() == -1
+
+
+def test_point3D():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ x1 = Symbol('x1', real=True)
+ x2 = Symbol('x2', real=True)
+ x3 = Symbol('x3', real=True)
+ y1 = Symbol('y1', real=True)
+ y2 = Symbol('y2', real=True)
+ y3 = Symbol('y3', real=True)
+ half = S.Half
+ p1 = Point3D(x1, x2, x3)
+ p2 = Point3D(y1, y2, y3)
+ p3 = Point3D(0, 0, 0)
+ p4 = Point3D(1, 1, 1)
+ p5 = Point3D(0, 1, 2)
+
+ assert p1 in p1
+ assert p1 not in p2
+ assert p2.y == y2
+ assert (p3 + p4) == p4
+ assert (p2 - p1) == Point3D(y1 - x1, y2 - x2, y3 - x3)
+ assert -p2 == Point3D(-y1, -y2, -y3)
+
+ assert Point(34.05, sqrt(3)) == Point(Rational(681, 20), sqrt(3))
+ assert Point3D.midpoint(p3, p4) == Point3D(half, half, half)
+ assert Point3D.midpoint(p1, p4) == Point3D(half + half*x1, half + half*x2,
+ half + half*x3)
+ assert Point3D.midpoint(p2, p2) == p2
+ assert p2.midpoint(p2) == p2
+
+ assert Point3D.distance(p3, p4) == sqrt(3)
+ assert Point3D.distance(p1, p1) == 0
+ assert Point3D.distance(p3, p2) == sqrt(p2.x**2 + p2.y**2 + p2.z**2)
+
+ p1_1 = Point3D(x1, x1, x1)
+ p1_2 = Point3D(y2, y2, y2)
+ p1_3 = Point3D(x1 + 1, x1, x1)
+ Point3D.are_collinear(p3)
+ assert Point3D.are_collinear(p3, p4)
+ assert Point3D.are_collinear(p3, p4, p1_1, p1_2)
+ assert Point3D.are_collinear(p3, p4, p1_1, p1_3) is False
+ assert Point3D.are_collinear(p3, p3, p4, p5) is False
+
+ assert p3.intersection(Point3D(0, 0, 0)) == [p3]
+ assert p3.intersection(p4) == []
+
+
+ assert p4 * 5 == Point3D(5, 5, 5)
+ assert p4 / 5 == Point3D(0.2, 0.2, 0.2)
+ assert 5 * p4 == Point3D(5, 5, 5)
+
+ raises(ValueError, lambda: Point3D(0, 0, 0) + 10)
+
+ # Test coordinate properties
+ assert p1.coordinates == (x1, x2, x3)
+ assert p2.coordinates == (y1, y2, y3)
+ assert p3.coordinates == (0, 0, 0)
+ assert p4.coordinates == (1, 1, 1)
+ assert p5.coordinates == (0, 1, 2)
+ assert p5.x == 0
+ assert p5.y == 1
+ assert p5.z == 2
+
+ # Point differences should be simplified
+ assert Point3D(x*(x - 1), y, 2) - Point3D(x**2 - x, y + 1, 1) == \
+ Point3D(0, -1, 1)
+
+ a, b, c = S.Half, Rational(1, 3), Rational(1, 4)
+ assert Point3D(a, b, c).evalf(2) == \
+ Point(a.n(2), b.n(2), c.n(2), evaluate=False)
+ raises(ValueError, lambda: Point3D(1, 2, 3) + 1)
+
+ # test transformations
+ p = Point3D(1, 1, 1)
+ assert p.scale(2, 3) == Point3D(2, 3, 1)
+ assert p.translate(1, 2) == Point3D(2, 3, 1)
+ assert p.translate(1) == Point3D(2, 1, 1)
+ assert p.translate(z=1) == Point3D(1, 1, 2)
+ assert p.translate(*p.args) == Point3D(2, 2, 2)
+
+ # Test __new__
+ assert Point3D(0.1, 0.2, evaluate=False, on_morph='ignore').args[0].is_Float
+
+ # Test length property returns correctly
+ assert p.length == 0
+ assert p1_1.length == 0
+ assert p1_2.length == 0
+
+ # Test are_colinear type error
+ raises(TypeError, lambda: Point3D.are_collinear(p, x))
+
+ # Test are_coplanar
+ assert Point.are_coplanar()
+ assert Point.are_coplanar((1, 2, 0), (1, 2, 0), (1, 3, 0))
+ assert Point.are_coplanar((1, 2, 0), (1, 2, 3))
+ with warns(UserWarning, test_stacklevel=False):
+ raises(ValueError, lambda: Point2D.are_coplanar((1, 2), (1, 2, 3)))
+ assert Point3D.are_coplanar((1, 2, 0), (1, 2, 3))
+ assert Point.are_coplanar((0, 0, 0), (1, 1, 0), (1, 1, 1), (1, 2, 1)) is False
+ planar2 = Point3D(1, -1, 1)
+ planar3 = Point3D(-1, 1, 1)
+ assert Point3D.are_coplanar(p, planar2, planar3) == True
+ assert Point3D.are_coplanar(p, planar2, planar3, p3) == False
+ assert Point.are_coplanar(p, planar2)
+ planar2 = Point3D(1, 1, 2)
+ planar3 = Point3D(1, 1, 3)
+ assert Point3D.are_coplanar(p, planar2, planar3) # line, not plane
+ plane = Plane((1, 2, 1), (2, 1, 0), (3, 1, 2))
+ assert Point.are_coplanar(*[plane.projection(((-1)**i, i)) for i in range(4)])
+
+ # all 2D points are coplanar
+ assert Point.are_coplanar(Point(x, y), Point(x, x + y), Point(y, x + 2)) is True
+
+ # Test Intersection
+ assert planar2.intersection(Line3D(p, planar3)) == [Point3D(1, 1, 2)]
+
+ # Test Scale
+ assert planar2.scale(1, 1, 1) == planar2
+ assert planar2.scale(2, 2, 2, planar3) == Point3D(1, 1, 1)
+ assert planar2.scale(1, 1, 1, p3) == planar2
+
+ # Test Transform
+ identity = Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
+ assert p.transform(identity) == p
+ trans = Matrix([[1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1, 1], [0, 0, 0, 1]])
+ assert p.transform(trans) == Point3D(2, 2, 2)
+ raises(ValueError, lambda: p.transform(p))
+ raises(ValueError, lambda: p.transform(Matrix([[1, 0], [0, 1]])))
+
+ # Test Equals
+ assert p.equals(x1) == False
+
+ # Test __sub__
+ p_4d = Point(0, 0, 0, 1)
+ with warns(UserWarning, test_stacklevel=False):
+ assert p - p_4d == Point(1, 1, 1, -1)
+ p_4d3d = Point(0, 0, 1, 0)
+ with warns(UserWarning, test_stacklevel=False):
+ assert p - p_4d3d == Point(1, 1, 0, 0)
+
+
+def test_Point2D():
+
+ # Test Distance
+ p1 = Point2D(1, 5)
+ p2 = Point2D(4, 2.5)
+ p3 = (6, 3)
+ assert p1.distance(p2) == sqrt(61)/2
+ assert p2.distance(p3) == sqrt(17)/2
+
+ # Test coordinates
+ assert p1.x == 1
+ assert p1.y == 5
+ assert p2.x == 4
+ assert p2.y == S(5)/2
+ assert p1.coordinates == (1, 5)
+ assert p2.coordinates == (4, S(5)/2)
+
+ # test bounds
+ assert p1.bounds == (1, 5, 1, 5)
+
+def test_issue_9214():
+ p1 = Point3D(4, -2, 6)
+ p2 = Point3D(1, 2, 3)
+ p3 = Point3D(7, 2, 3)
+
+ assert Point3D.are_collinear(p1, p2, p3) is False
+
+
+def test_issue_11617():
+ p1 = Point3D(1,0,2)
+ p2 = Point2D(2,0)
+
+ with warns(UserWarning, test_stacklevel=False):
+ assert p1.distance(p2) == sqrt(5)
+
+
+def test_transform():
+ p = Point(1, 1)
+ assert p.transform(rotate(pi/2)) == Point(-1, 1)
+ assert p.transform(scale(3, 2)) == Point(3, 2)
+ assert p.transform(translate(1, 2)) == Point(2, 3)
+ assert Point(1, 1).scale(2, 3, (4, 5)) == \
+ Point(-2, -7)
+ assert Point(1, 1).translate(4, 5) == \
+ Point(5, 6)
+
+
+def test_concyclic_doctest_bug():
+ p1, p2 = Point(-1, 0), Point(1, 0)
+ p3, p4 = Point(0, 1), Point(-1, 2)
+ assert Point.is_concyclic(p1, p2, p3)
+ assert not Point.is_concyclic(p1, p2, p3, p4)
+
+
+def test_arguments():
+ """Functions accepting `Point` objects in `geometry`
+ should also accept tuples and lists and
+ automatically convert them to points."""
+
+ singles2d = ((1,2), [1,2], Point(1,2))
+ singles2d2 = ((1,3), [1,3], Point(1,3))
+ doubles2d = cartes(singles2d, singles2d2)
+ p2d = Point2D(1,2)
+ singles3d = ((1,2,3), [1,2,3], Point(1,2,3))
+ doubles3d = subsets(singles3d, 2)
+ p3d = Point3D(1,2,3)
+ singles4d = ((1,2,3,4), [1,2,3,4], Point(1,2,3,4))
+ doubles4d = subsets(singles4d, 2)
+ p4d = Point(1,2,3,4)
+
+ # test 2D
+ test_single = ['distance', 'is_scalar_multiple', 'taxicab_distance', 'midpoint', 'intersection', 'dot', 'equals', '__add__', '__sub__']
+ test_double = ['is_concyclic', 'is_collinear']
+ for p in singles2d:
+ Point2D(p)
+ for func in test_single:
+ for p in singles2d:
+ getattr(p2d, func)(p)
+ for func in test_double:
+ for p in doubles2d:
+ getattr(p2d, func)(*p)
+
+ # test 3D
+ test_double = ['is_collinear']
+ for p in singles3d:
+ Point3D(p)
+ for func in test_single:
+ for p in singles3d:
+ getattr(p3d, func)(p)
+ for func in test_double:
+ for p in doubles3d:
+ getattr(p3d, func)(*p)
+
+ # test 4D
+ test_double = ['is_collinear']
+ for p in singles4d:
+ Point(p)
+ for func in test_single:
+ for p in singles4d:
+ getattr(p4d, func)(p)
+ for func in test_double:
+ for p in doubles4d:
+ getattr(p4d, func)(*p)
+
+ # test evaluate=False for ops
+ x = Symbol('x')
+ a = Point(0, 1)
+ assert a + (0.1, x) == Point(0.1, 1 + x, evaluate=False)
+ a = Point(0, 1)
+ assert a/10.0 == Point(0, 0.1, evaluate=False)
+ a = Point(0, 1)
+ assert a*10.0 == Point(0.0, 10.0, evaluate=False)
+
+ # test evaluate=False when changing dimensions
+ u = Point(.1, .2, evaluate=False)
+ u4 = Point(u, dim=4, on_morph='ignore')
+ assert u4.args == (.1, .2, 0, 0)
+ assert all(i.is_Float for i in u4.args[:2])
+ # and even when *not* changing dimensions
+ assert all(i.is_Float for i in Point(u).args)
+
+ # never raise error if creating an origin
+ assert Point(dim=3, on_morph='error')
+
+ # raise error with unmatched dimension
+ raises(ValueError, lambda: Point(1, 1, dim=3, on_morph='error'))
+ # test unknown on_morph
+ raises(ValueError, lambda: Point(1, 1, dim=3, on_morph='unknown'))
+ # test invalid expressions
+ raises(TypeError, lambda: Point(Basic(), Basic()))
+
+def test_unit():
+ assert Point(1, 1).unit == Point(sqrt(2)/2, sqrt(2)/2)
+
+
+def test_dot():
+ raises(TypeError, lambda: Point(1, 2).dot(Line((0, 0), (1, 1))))
+
+
+def test__normalize_dimension():
+ assert Point._normalize_dimension(Point(1, 2), Point(3, 4)) == [
+ Point(1, 2), Point(3, 4)]
+ assert Point._normalize_dimension(
+ Point(1, 2), Point(3, 4, 0), on_morph='ignore') == [
+ Point(1, 2, 0), Point(3, 4, 0)]
+
+
+def test_issue_22684():
+ # Used to give an error
+ with evaluate(False):
+ Point(1, 2)
+
+
+def test_direction_cosine():
+ p1 = Point3D(0, 0, 0)
+ p2 = Point3D(1, 1, 1)
+
+ assert p1.direction_cosine(Point3D(1, 0, 0)) == [1, 0, 0]
+ assert p1.direction_cosine(Point3D(0, 1, 0)) == [0, 1, 0]
+ assert p1.direction_cosine(Point3D(0, 0, pi)) == [0, 0, 1]
+
+ assert p1.direction_cosine(Point3D(5, 0, 0)) == [1, 0, 0]
+ assert p1.direction_cosine(Point3D(0, sqrt(3), 0)) == [0, 1, 0]
+ assert p1.direction_cosine(Point3D(0, 0, 5)) == [0, 0, 1]
+
+ assert p1.direction_cosine(Point3D(2.4, 2.4, 0)) == [sqrt(2)/2, sqrt(2)/2, 0]
+ assert p1.direction_cosine(Point3D(1, 1, 1)) == [sqrt(3) / 3, sqrt(3) / 3, sqrt(3) / 3]
+ assert p1.direction_cosine(Point3D(-12, 0 -15)) == [-4*sqrt(41)/41, -5*sqrt(41)/41, 0]
+
+ assert p2.direction_cosine(Point3D(0, 0, 0)) == [-sqrt(3) / 3, -sqrt(3) / 3, -sqrt(3) / 3]
+ assert p2.direction_cosine(Point3D(1, 1, 12)) == [0, 0, 1]
+ assert p2.direction_cosine(Point3D(12, 1, 12)) == [sqrt(2) / 2, 0, sqrt(2) / 2]
diff --git a/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_polygon.py b/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_polygon.py
new file mode 100644
index 0000000000000000000000000000000000000000..976d71078a4ef8d535a9508a64f414c80da16847
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/geometry/tests/test_polygon.py
@@ -0,0 +1,676 @@
+from sympy.core.numbers import (Float, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, cos, sin)
+from sympy.functions.elementary.trigonometric import tan
+from sympy.geometry import (Circle, Ellipse, GeometryError, Point, Point2D,
+ Polygon, Ray, RegularPolygon, Segment, Triangle,
+ are_similar, convex_hull, intersection, Line, Ray2D)
+from sympy.testing.pytest import raises, slow, warns
+from sympy.core.random import verify_numerically
+from sympy.geometry.polygon import rad, deg
+from sympy.integrals.integrals import integrate
+from sympy.utilities.iterables import rotate_left
+
+
+def feq(a, b):
+ """Test if two floating point values are 'equal'."""
+ t_float = Float("1.0E-10")
+ return -t_float < a - b < t_float
+
+@slow
+def test_polygon():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ q = Symbol('q', real=True)
+ u = Symbol('u', real=True)
+ v = Symbol('v', real=True)
+ w = Symbol('w', real=True)
+ x1 = Symbol('x1', real=True)
+ half = S.Half
+ a, b, c = Point(0, 0), Point(2, 0), Point(3, 3)
+ t = Triangle(a, b, c)
+ assert Polygon(Point(0, 0)) == Point(0, 0)
+ assert Polygon(a, Point(1, 0), b, c) == t
+ assert Polygon(Point(1, 0), b, c, a) == t
+ assert Polygon(b, c, a, Point(1, 0)) == t
+ # 2 "remove folded" tests
+ assert Polygon(a, Point(3, 0), b, c) == t
+ assert Polygon(a, b, Point(3, -1), b, c) == t
+ # remove multiple collinear points
+ assert Polygon(Point(-4, 15), Point(-11, 15), Point(-15, 15),
+ Point(-15, 33/5), Point(-15, -87/10), Point(-15, -15),
+ Point(-42/5, -15), Point(-2, -15), Point(7, -15), Point(15, -15),
+ Point(15, -3), Point(15, 10), Point(15, 15)) == \
+ Polygon(Point(-15, -15), Point(15, -15), Point(15, 15), Point(-15, 15))
+
+ p1 = Polygon(
+ Point(0, 0), Point(3, -1),
+ Point(6, 0), Point(4, 5),
+ Point(2, 3), Point(0, 3))
+ p2 = Polygon(
+ Point(6, 0), Point(3, -1),
+ Point(0, 0), Point(0, 3),
+ Point(2, 3), Point(4, 5))
+ p3 = Polygon(
+ Point(0, 0), Point(3, 0),
+ Point(5, 2), Point(4, 4))
+ p4 = Polygon(
+ Point(0, 0), Point(4, 4),
+ Point(5, 2), Point(3, 0))
+ p5 = Polygon(
+ Point(0, 0), Point(4, 4),
+ Point(0, 4))
+ p6 = Polygon(
+ Point(-11, 1), Point(-9, 6.6),
+ Point(-4, -3), Point(-8.4, -8.7))
+ p7 = Polygon(
+ Point(x, y), Point(q, u),
+ Point(v, w))
+ p8 = Polygon(
+ Point(x, y), Point(v, w),
+ Point(q, u))
+ p9 = Polygon(
+ Point(0, 0), Point(4, 4),
+ Point(3, 0), Point(5, 2))
+ p10 = Polygon(
+ Point(0, 2), Point(2, 2),
+ Point(0, 0), Point(2, 0))
+ p11 = Polygon(Point(0, 0), 1, n=3)
+ p12 = Polygon(Point(0, 0), 1, 0, n=3)
+ p13 = Polygon(
+ Point(0, 0),Point(8, 8),
+ Point(23, 20),Point(0, 20))
+ p14 = Polygon(*rotate_left(p13.args, 1))
+
+
+ r = Ray(Point(-9, 6.6), Point(-9, 5.5))
+ #
+ # General polygon
+ #
+ assert p1 == p2
+ assert len(p1.args) == 6
+ assert len(p1.sides) == 6
+ assert p1.perimeter == 5 + 2*sqrt(10) + sqrt(29) + sqrt(8)
+ assert p1.area == 22
+ assert not p1.is_convex()
+ assert Polygon((-1, 1), (2, -1), (2, 1), (-1, -1), (3, 0)
+ ).is_convex() is False
+ # ensure convex for both CW and CCW point specification
+ assert p3.is_convex()
+ assert p4.is_convex()
+ dict5 = p5.angles
+ assert dict5[Point(0, 0)] == pi / 4
+ assert dict5[Point(0, 4)] == pi / 2
+ assert p5.encloses_point(Point(x, y)) is None
+ assert p5.encloses_point(Point(1, 3))
+ assert p5.encloses_point(Point(0, 0)) is False
+ assert p5.encloses_point(Point(4, 0)) is False
+ assert p1.encloses(Circle(Point(2.5, 2.5), 5)) is False
+ assert p1.encloses(Ellipse(Point(2.5, 2), 5, 6)) is False
+ assert p5.plot_interval('x') == [x, 0, 1]
+ assert p5.distance(
+ Polygon(Point(10, 10), Point(14, 14), Point(10, 14))) == 6 * sqrt(2)
+ assert p5.distance(
+ Polygon(Point(1, 8), Point(5, 8), Point(8, 12), Point(1, 12))) == 4
+ with warns(UserWarning, \
+ match="Polygons may intersect producing erroneous output"):
+ Polygon(Point(0, 0), Point(1, 0), Point(1, 1)).distance(
+ Polygon(Point(0, 0), Point(0, 1), Point(1, 1)))
+ assert hash(p5) == hash(Polygon(Point(0, 0), Point(4, 4), Point(0, 4)))
+ assert hash(p1) == hash(p2)
+ assert hash(p7) == hash(p8)
+ assert hash(p3) != hash(p9)
+ assert p5 == Polygon(Point(4, 4), Point(0, 4), Point(0, 0))
+ assert Polygon(Point(4, 4), Point(0, 4), Point(0, 0)) in p5
+ assert p5 != Point(0, 4)
+ assert Point(0, 1) in p5
+ assert p5.arbitrary_point('t').subs(Symbol('t', real=True), 0) == \
+ Point(0, 0)
+ raises(ValueError, lambda: Polygon(
+ Point(x, 0), Point(0, y), Point(x, y)).arbitrary_point('x'))
+ assert p6.intersection(r) == [Point(-9, Rational(-84, 13)), Point(-9, Rational(33, 5))]
+ assert p10.area == 0
+ assert p11 == RegularPolygon(Point(0, 0), 1, 3, 0)
+ assert p11 == p12
+ assert p11.vertices[0] == Point(1, 0)
+ assert p11.args[0] == Point(0, 0)
+ p11.spin(pi/2)
+ assert p11.vertices[0] == Point(0, 1)
+ #
+ # Regular polygon
+ #
+ p1 = RegularPolygon(Point(0, 0), 10, 5)
+ p2 = RegularPolygon(Point(0, 0), 5, 5)
+ raises(GeometryError, lambda: RegularPolygon(Point(0, 0), Point(0,
+ 1), Point(1, 1)))
+ raises(GeometryError, lambda: RegularPolygon(Point(0, 0), 1, 2))
+ raises(ValueError, lambda: RegularPolygon(Point(0, 0), 1, 2.5))
+
+ assert p1 != p2
+ assert p1.interior_angle == pi*Rational(3, 5)
+ assert p1.exterior_angle == pi*Rational(2, 5)
+ assert p2.apothem == 5*cos(pi/5)
+ assert p2.circumcenter == p1.circumcenter == Point(0, 0)
+ assert p1.circumradius == p1.radius == 10
+ assert p2.circumcircle == Circle(Point(0, 0), 5)
+ assert p2.incircle == Circle(Point(0, 0), p2.apothem)
+ assert p2.inradius == p2.apothem == (5 * (1 + sqrt(5)) / 4)
+ p2.spin(pi / 10)
+ dict1 = p2.angles
+ assert dict1[Point(0, 5)] == 3 * pi / 5
+ assert p1.is_convex()
+ assert p1.rotation == 0
+ assert p1.encloses_point(Point(0, 0))
+ assert p1.encloses_point(Point(11, 0)) is False
+ assert p2.encloses_point(Point(0, 4.9))
+ p1.spin(pi/3)
+ assert p1.rotation == pi/3
+ assert p1.vertices[0] == Point(5, 5*sqrt(3))
+ for var in p1.args:
+ if isinstance(var, Point):
+ assert var == Point(0, 0)
+ else:
+ assert var in (5, 10, pi / 3)
+ assert p1 != Point(0, 0)
+ assert p1 != p5
+
+ # while spin works in place (notice that rotation is 2pi/3 below)
+ # rotate returns a new object
+ p1_old = p1
+ assert p1.rotate(pi/3) == RegularPolygon(Point(0, 0), 10, 5, pi*Rational(2, 3))
+ assert p1 == p1_old
+
+ assert p1.area == (-250*sqrt(5) + 1250)/(4*tan(pi/5))
+ assert p1.length == 20*sqrt(-sqrt(5)/8 + Rational(5, 8))
+ assert p1.scale(2, 2) == \
+ RegularPolygon(p1.center, p1.radius*2, p1._n, p1.rotation)
+ assert RegularPolygon((0, 0), 1, 4).scale(2, 3) == \
+ Polygon(Point(2, 0), Point(0, 3), Point(-2, 0), Point(0, -3))
+
+ assert repr(p1) == str(p1)
+
+ #
+ # Angles
+ #
+ angles = p4.angles
+ assert feq(angles[Point(0, 0)].evalf(), Float("0.7853981633974483"))
+ assert feq(angles[Point(4, 4)].evalf(), Float("1.2490457723982544"))
+ assert feq(angles[Point(5, 2)].evalf(), Float("1.8925468811915388"))
+ assert feq(angles[Point(3, 0)].evalf(), Float("2.3561944901923449"))
+
+ angles = p3.angles
+ assert feq(angles[Point(0, 0)].evalf(), Float("0.7853981633974483"))
+ assert feq(angles[Point(4, 4)].evalf(), Float("1.2490457723982544"))
+ assert feq(angles[Point(5, 2)].evalf(), Float("1.8925468811915388"))
+ assert feq(angles[Point(3, 0)].evalf(), Float("2.3561944901923449"))
+
+ # https://github.com/sympy/sympy/issues/24885
+ interior_angles_sum = sum(p13.angles.values())
+ assert feq(interior_angles_sum, (len(p13.angles) - 2)*pi )
+ interior_angles_sum = sum(p14.angles.values())
+ assert feq(interior_angles_sum, (len(p14.angles) - 2)*pi )
+
+ #
+ # Triangle
+ #
+ p1 = Point(0, 0)
+ p2 = Point(5, 0)
+ p3 = Point(0, 5)
+ t1 = Triangle(p1, p2, p3)
+ t2 = Triangle(p1, p2, Point(Rational(5, 2), sqrt(Rational(75, 4))))
+ t3 = Triangle(p1, Point(x1, 0), Point(0, x1))
+ s1 = t1.sides
+ assert Triangle(p1, p2, p1) == Polygon(p1, p2, p1) == Segment(p1, p2)
+ raises(GeometryError, lambda: Triangle(Point(0, 0)))
+
+ # Basic stuff
+ assert Triangle(p1, p1, p1) == p1
+ assert Triangle(p2, p2*2, p2*3) == Segment(p2, p2*3)
+ assert t1.area == Rational(25, 2)
+ assert t1.is_right()
+ assert t2.is_right() is False
+ assert t3.is_right()
+ assert p1 in t1
+ assert t1.sides[0] in t1
+ assert Segment((0, 0), (1, 0)) in t1
+ assert Point(5, 5) not in t2
+ assert t1.is_convex()
+ assert feq(t1.angles[p1].evalf(), pi.evalf()/2)
+
+ assert t1.is_equilateral() is False
+ assert t2.is_equilateral()
+ assert t3.is_equilateral() is False
+ assert are_similar(t1, t2) is False
+ assert are_similar(t1, t3)
+ assert are_similar(t2, t3) is False
+ assert t1.is_similar(Point(0, 0)) is False
+ assert t1.is_similar(t2) is False
+
+ # Bisectors
+ bisectors = t1.bisectors()
+ assert bisectors[p1] == Segment(
+ p1, Point(Rational(5, 2), Rational(5, 2)))
+ assert t2.bisectors()[p2] == Segment(
+ Point(5, 0), Point(Rational(5, 4), 5*sqrt(3)/4))
+ p4 = Point(0, x1)
+ assert t3.bisectors()[p4] == Segment(p4, Point(x1*(sqrt(2) - 1), 0))
+ ic = (250 - 125*sqrt(2))/50
+ assert t1.incenter == Point(ic, ic)
+
+ # Inradius
+ assert t1.inradius == t1.incircle.radius == 5 - 5*sqrt(2)/2
+ assert t2.inradius == t2.incircle.radius == 5*sqrt(3)/6
+ assert t3.inradius == t3.incircle.radius == x1**2/((2 + sqrt(2))*Abs(x1))
+
+ # Exradius
+ assert t1.exradii[t1.sides[2]] == 5*sqrt(2)/2
+
+ # Excenters
+ assert t1.excenters[t1.sides[2]] == Point2D(25*sqrt(2), -5*sqrt(2)/2)
+
+ # Circumcircle
+ assert t1.circumcircle.center == Point(2.5, 2.5)
+
+ # Medians + Centroid
+ m = t1.medians
+ assert t1.centroid == Point(Rational(5, 3), Rational(5, 3))
+ assert m[p1] == Segment(p1, Point(Rational(5, 2), Rational(5, 2)))
+ assert t3.medians[p1] == Segment(p1, Point(x1/2, x1/2))
+ assert intersection(m[p1], m[p2], m[p3]) == [t1.centroid]
+ assert t1.medial == Triangle(Point(2.5, 0), Point(0, 2.5), Point(2.5, 2.5))
+
+ # Nine-point circle
+ assert t1.nine_point_circle == Circle(Point(2.5, 0),
+ Point(0, 2.5), Point(2.5, 2.5))
+ assert t1.nine_point_circle == Circle(Point(0, 0),
+ Point(0, 2.5), Point(2.5, 2.5))
+
+ # Perpendicular
+ altitudes = t1.altitudes
+ assert altitudes[p1] == Segment(p1, Point(Rational(5, 2), Rational(5, 2)))
+ assert altitudes[p2].equals(s1[0])
+ assert altitudes[p3] == s1[2]
+ assert t1.orthocenter == p1
+ t = S('''Triangle(
+ Point(100080156402737/5000000000000, 79782624633431/500000000000),
+ Point(39223884078253/2000000000000, 156345163124289/1000000000000),
+ Point(31241359188437/1250000000000, 338338270939941/1000000000000000))''')
+ assert t.orthocenter == S('''Point(-780660869050599840216997'''
+ '''79471538701955848721853/80368430960602242240789074233100000000000000,'''
+ '''20151573611150265741278060334545897615974257/16073686192120448448157'''
+ '''8148466200000000000)''')
+
+ # Ensure
+ assert len(intersection(*bisectors.values())) == 1
+ assert len(intersection(*altitudes.values())) == 1
+ assert len(intersection(*m.values())) == 1
+
+ # Distance
+ p1 = Polygon(
+ Point(0, 0), Point(1, 0),
+ Point(1, 1), Point(0, 1))
+ p2 = Polygon(
+ Point(0, Rational(5)/4), Point(1, Rational(5)/4),
+ Point(1, Rational(9)/4), Point(0, Rational(9)/4))
+ p3 = Polygon(
+ Point(1, 2), Point(2, 2),
+ Point(2, 1))
+ p4 = Polygon(
+ Point(1, 1), Point(Rational(6)/5, 1),
+ Point(1, Rational(6)/5))
+ pt1 = Point(half, half)
+ pt2 = Point(1, 1)
+
+ '''Polygon to Point'''
+ assert p1.distance(pt1) == half
+ assert p1.distance(pt2) == 0
+ assert p2.distance(pt1) == Rational(3)/4
+ assert p3.distance(pt2) == sqrt(2)/2
+
+ '''Polygon to Polygon'''
+ # p1.distance(p2) emits a warning
+ with warns(UserWarning, \
+ match="Polygons may intersect producing erroneous output"):
+ assert p1.distance(p2) == half/2
+
+ assert p1.distance(p3) == sqrt(2)/2
+
+ # p3.distance(p4) emits a warning
+ with warns(UserWarning, \
+ match="Polygons may intersect producing erroneous output"):
+ assert p3.distance(p4) == (sqrt(2)/2 - sqrt(Rational(2)/25)/2)
+
+
+def test_convex_hull():
+ p = [Point(-5, -1), Point(-2, 1), Point(-2, -1), Point(-1, -3), \
+ Point(0, 0), Point(1, 1), Point(2, 2), Point(2, -1), Point(3, 1), \
+ Point(4, -1), Point(6, 2)]
+ ch = Polygon(p[0], p[3], p[9], p[10], p[6], p[1])
+ #test handling of duplicate points
+ p.append(p[3])
+
+ #more than 3 collinear points
+ another_p = [Point(-45, -85), Point(-45, 85), Point(-45, 26), \
+ Point(-45, -24)]
+ ch2 = Segment(another_p[0], another_p[1])
+
+ assert convex_hull(*another_p) == ch2
+ assert convex_hull(*p) == ch
+ assert convex_hull(p[0]) == p[0]
+ assert convex_hull(p[0], p[1]) == Segment(p[0], p[1])
+
+ # no unique points
+ assert convex_hull(*[p[-1]]*3) == p[-1]
+
+ # collection of items
+ assert convex_hull(*[Point(0, 0), \
+ Segment(Point(1, 0), Point(1, 1)), \
+ RegularPolygon(Point(2, 0), 2, 4)]) == \
+ Polygon(Point(0, 0), Point(2, -2), Point(4, 0), Point(2, 2))
+
+
+def test_encloses():
+ # square with a dimpled left side
+ s = Polygon(Point(0, 0), Point(1, 0), Point(1, 1), Point(0, 1), \
+ Point(S.Half, S.Half))
+ # the following is True if the polygon isn't treated as closing on itself
+ assert s.encloses(Point(0, S.Half)) is False
+ assert s.encloses(Point(S.Half, S.Half)) is False # it's a vertex
+ assert s.encloses(Point(Rational(3, 4), S.Half)) is True
+
+
+def test_triangle_kwargs():
+ assert Triangle(sss=(3, 4, 5)) == \
+ Triangle(Point(0, 0), Point(3, 0), Point(3, 4))
+ assert Triangle(asa=(30, 2, 30)) == \
+ Triangle(Point(0, 0), Point(2, 0), Point(1, sqrt(3)/3))
+ assert Triangle(sas=(1, 45, 2)) == \
+ Triangle(Point(0, 0), Point(2, 0), Point(sqrt(2)/2, sqrt(2)/2))
+ assert Triangle(sss=(1, 2, 5)) is None
+ assert deg(rad(180)) == 180
+
+
+def test_transform():
+ pts = [Point(0, 0), Point(S.Half, Rational(1, 4)), Point(1, 1)]
+ pts_out = [Point(-4, -10), Point(-3, Rational(-37, 4)), Point(-2, -7)]
+ assert Triangle(*pts).scale(2, 3, (4, 5)) == Triangle(*pts_out)
+ assert RegularPolygon((0, 0), 1, 4).scale(2, 3, (4, 5)) == \
+ Polygon(Point(-2, -10), Point(-4, -7), Point(-6, -10), Point(-4, -13))
+ # Checks for symmetric scaling
+ assert RegularPolygon((0, 0), 1, 4).scale(2, 2) == \
+ RegularPolygon(Point2D(0, 0), 2, 4, 0)
+
+def test_reflect():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ b = Symbol('b')
+ m = Symbol('m')
+ l = Line((0, b), slope=m)
+ p = Point(x, y)
+ r = p.reflect(l)
+ dp = l.perpendicular_segment(p).length
+ dr = l.perpendicular_segment(r).length
+
+ assert verify_numerically(dp, dr)
+
+ assert Polygon((1, 0), (2, 0), (2, 2)).reflect(Line((3, 0), slope=oo)) \
+ == Triangle(Point(5, 0), Point(4, 0), Point(4, 2))
+ assert Polygon((1, 0), (2, 0), (2, 2)).reflect(Line((0, 3), slope=oo)) \
+ == Triangle(Point(-1, 0), Point(-2, 0), Point(-2, 2))
+ assert Polygon((1, 0), (2, 0), (2, 2)).reflect(Line((0, 3), slope=0)) \
+ == Triangle(Point(1, 6), Point(2, 6), Point(2, 4))
+ assert Polygon((1, 0), (2, 0), (2, 2)).reflect(Line((3, 0), slope=0)) \
+ == Triangle(Point(1, 0), Point(2, 0), Point(2, -2))
+
+def test_bisectors():
+ p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+ p = Polygon(Point(0, 0), Point(2, 0), Point(1, 1), Point(0, 3))
+ q = Polygon(Point(1, 0), Point(2, 0), Point(3, 3), Point(-1, 5))
+ poly = Polygon(Point(3, 4), Point(0, 0), Point(8, 7), Point(-1, 1), Point(19, -19))
+ t = Triangle(p1, p2, p3)
+ assert t.bisectors()[p2] == Segment(Point(1, 0), Point(0, sqrt(2) - 1))
+ assert p.bisectors()[Point2D(0, 3)] == Ray2D(Point2D(0, 3), \
+ Point2D(sin(acos(2*sqrt(5)/5)/2), 3 - cos(acos(2*sqrt(5)/5)/2)))
+ assert q.bisectors()[Point2D(-1, 5)] == \
+ Ray2D(Point2D(-1, 5), Point2D(-1 + sqrt(29)*(5*sin(acos(9*sqrt(145)/145)/2) + \
+ 2*cos(acos(9*sqrt(145)/145)/2))/29, sqrt(29)*(-5*cos(acos(9*sqrt(145)/145)/2) + \
+ 2*sin(acos(9*sqrt(145)/145)/2))/29 + 5))
+ assert poly.bisectors()[Point2D(-1, 1)] == Ray2D(Point2D(-1, 1), \
+ Point2D(-1 + sin(acos(sqrt(26)/26)/2 + pi/4), 1 - sin(-acos(sqrt(26)/26)/2 + pi/4)))
+
+def test_incenter():
+ assert Triangle(Point(0, 0), Point(1, 0), Point(0, 1)).incenter \
+ == Point(1 - sqrt(2)/2, 1 - sqrt(2)/2)
+
+def test_inradius():
+ assert Triangle(Point(0, 0), Point(4, 0), Point(0, 3)).inradius == 1
+
+def test_incircle():
+ assert Triangle(Point(0, 0), Point(2, 0), Point(0, 2)).incircle \
+ == Circle(Point(2 - sqrt(2), 2 - sqrt(2)), 2 - sqrt(2))
+
+def test_exradii():
+ t = Triangle(Point(0, 0), Point(6, 0), Point(0, 2))
+ assert t.exradii[t.sides[2]] == (-2 + sqrt(10))
+
+def test_medians():
+ t = Triangle(Point(0, 0), Point(1, 0), Point(0, 1))
+ assert t.medians[Point(0, 0)] == Segment(Point(0, 0), Point(S.Half, S.Half))
+
+def test_medial():
+ assert Triangle(Point(0, 0), Point(1, 0), Point(0, 1)).medial \
+ == Triangle(Point(S.Half, 0), Point(S.Half, S.Half), Point(0, S.Half))
+
+def test_nine_point_circle():
+ assert Triangle(Point(0, 0), Point(1, 0), Point(0, 1)).nine_point_circle \
+ == Circle(Point2D(Rational(1, 4), Rational(1, 4)), sqrt(2)/4)
+
+def test_eulerline():
+ assert Triangle(Point(0, 0), Point(1, 0), Point(0, 1)).eulerline \
+ == Line(Point2D(0, 0), Point2D(S.Half, S.Half))
+ assert Triangle(Point(0, 0), Point(10, 0), Point(5, 5*sqrt(3))).eulerline \
+ == Point2D(5, 5*sqrt(3)/3)
+ assert Triangle(Point(4, -6), Point(4, -1), Point(-3, 3)).eulerline \
+ == Line(Point2D(Rational(64, 7), 3), Point2D(Rational(-29, 14), Rational(-7, 2)))
+
+def test_intersection():
+ poly1 = Triangle(Point(0, 0), Point(1, 0), Point(0, 1))
+ poly2 = Polygon(Point(0, 1), Point(-5, 0),
+ Point(0, -4), Point(0, Rational(1, 5)),
+ Point(S.Half, -0.1), Point(1, 0), Point(0, 1))
+
+ assert poly1.intersection(poly2) == [Point2D(Rational(1, 3), 0),
+ Segment(Point(0, Rational(1, 5)), Point(0, 0)),
+ Segment(Point(1, 0), Point(0, 1))]
+ assert poly2.intersection(poly1) == [Point(Rational(1, 3), 0),
+ Segment(Point(0, 0), Point(0, Rational(1, 5))),
+ Segment(Point(1, 0), Point(0, 1))]
+ assert poly1.intersection(Point(0, 0)) == [Point(0, 0)]
+ assert poly1.intersection(Point(-12, -43)) == []
+ assert poly2.intersection(Line((-12, 0), (12, 0))) == [Point(-5, 0),
+ Point(0, 0), Point(Rational(1, 3), 0), Point(1, 0)]
+ assert poly2.intersection(Line((-12, 12), (12, 12))) == []
+ assert poly2.intersection(Ray((-3, 4), (1, 0))) == [Segment(Point(1, 0),
+ Point(0, 1))]
+ assert poly2.intersection(Circle((0, -1), 1)) == [Point(0, -2),
+ Point(0, 0)]
+ assert poly1.intersection(poly1) == [Segment(Point(0, 0), Point(1, 0)),
+ Segment(Point(0, 1), Point(0, 0)), Segment(Point(1, 0), Point(0, 1))]
+ assert poly2.intersection(poly2) == [Segment(Point(-5, 0), Point(0, -4)),
+ Segment(Point(0, -4), Point(0, Rational(1, 5))),
+ Segment(Point(0, Rational(1, 5)), Point(S.Half, Rational(-1, 10))),
+ Segment(Point(0, 1), Point(-5, 0)),
+ Segment(Point(S.Half, Rational(-1, 10)), Point(1, 0)),
+ Segment(Point(1, 0), Point(0, 1))]
+ assert poly2.intersection(Triangle(Point(0, 1), Point(1, 0), Point(-1, 1))) \
+ == [Point(Rational(-5, 7), Rational(6, 7)), Segment(Point2D(0, 1), Point(1, 0))]
+ assert poly1.intersection(RegularPolygon((-12, -15), 3, 3)) == []
+
+
+def test_parameter_value():
+ t = Symbol('t')
+ sq = Polygon((0, 0), (0, 1), (1, 1), (1, 0))
+ assert sq.parameter_value((0.5, 1), t) == {t: Rational(3, 8)}
+ q = Polygon((0, 0), (2, 1), (2, 4), (4, 0))
+ assert q.parameter_value((4, 0), t) == {t: -6 + 3*sqrt(5)} # ~= 0.708
+
+ raises(ValueError, lambda: sq.parameter_value((5, 6), t))
+ raises(ValueError, lambda: sq.parameter_value(Circle(Point(0, 0), 1), t))
+
+
+def test_issue_12966():
+ poly = Polygon(Point(0, 0), Point(0, 10), Point(5, 10), Point(5, 5),
+ Point(10, 5), Point(10, 0))
+ t = Symbol('t')
+ pt = poly.arbitrary_point(t)
+ DELTA = 5/poly.perimeter
+ assert [pt.subs(t, DELTA*i) for i in range(int(1/DELTA))] == [
+ Point(0, 0), Point(0, 5), Point(0, 10), Point(5, 10),
+ Point(5, 5), Point(10, 5), Point(10, 0), Point(5, 0)]
+
+
+def test_second_moment_of_area():
+ x, y = symbols('x, y')
+ # triangle
+ p1, p2, p3 = [(0, 0), (4, 0), (0, 2)]
+ p = (0, 0)
+ # equation of hypotenuse
+ eq_y = (1-x/4)*2
+ I_yy = integrate((x**2) * (integrate(1, (y, 0, eq_y))), (x, 0, 4))
+ I_xx = integrate(1 * (integrate(y**2, (y, 0, eq_y))), (x, 0, 4))
+ I_xy = integrate(x * (integrate(y, (y, 0, eq_y))), (x, 0, 4))
+
+ triangle = Polygon(p1, p2, p3)
+
+ assert (I_xx - triangle.second_moment_of_area(p)[0]) == 0
+ assert (I_yy - triangle.second_moment_of_area(p)[1]) == 0
+ assert (I_xy - triangle.second_moment_of_area(p)[2]) == 0
+
+ # rectangle
+ p1, p2, p3, p4=[(0, 0), (4, 0), (4, 2), (0, 2)]
+ I_yy = integrate((x**2) * integrate(1, (y, 0, 2)), (x, 0, 4))
+ I_xx = integrate(1 * integrate(y**2, (y, 0, 2)), (x, 0, 4))
+ I_xy = integrate(x * integrate(y, (y, 0, 2)), (x, 0, 4))
+
+ rectangle = Polygon(p1, p2, p3, p4)
+
+ assert (I_xx - rectangle.second_moment_of_area(p)[0]) == 0
+ assert (I_yy - rectangle.second_moment_of_area(p)[1]) == 0
+ assert (I_xy - rectangle.second_moment_of_area(p)[2]) == 0
+
+
+ r = RegularPolygon(Point(0, 0), 5, 3)
+ assert r.second_moment_of_area() == (1875*sqrt(3)/S(32), 1875*sqrt(3)/S(32), 0)
+
+
+def test_first_moment():
+ a, b = symbols('a, b', positive=True)
+ # rectangle
+ p1 = Polygon((0, 0), (a, 0), (a, b), (0, b))
+ assert p1.first_moment_of_area() == (a*b**2/8, a**2*b/8)
+ assert p1.first_moment_of_area((a/3, b/4)) == (-3*a*b**2/32, -a**2*b/9)
+
+ p1 = Polygon((0, 0), (40, 0), (40, 30), (0, 30))
+ assert p1.first_moment_of_area() == (4500, 6000)
+
+ # triangle
+ p2 = Polygon((0, 0), (a, 0), (a/2, b))
+ assert p2.first_moment_of_area() == (4*a*b**2/81, a**2*b/24)
+ assert p2.first_moment_of_area((a/8, b/6)) == (-25*a*b**2/648, -5*a**2*b/768)
+
+ p2 = Polygon((0, 0), (12, 0), (12, 30))
+ assert p2.first_moment_of_area() == (S(1600)/3, -S(640)/3)
+
+
+def test_section_modulus_and_polar_second_moment_of_area():
+ a, b = symbols('a, b', positive=True)
+ x, y = symbols('x, y')
+ rectangle = Polygon((0, b), (0, 0), (a, 0), (a, b))
+ assert rectangle.section_modulus(Point(x, y)) == (a*b**3/12/(-b/2 + y), a**3*b/12/(-a/2 + x))
+ assert rectangle.polar_second_moment_of_area() == a**3*b/12 + a*b**3/12
+
+ convex = RegularPolygon((0, 0), 1, 6)
+ assert convex.section_modulus() == (Rational(5, 8), sqrt(3)*Rational(5, 16))
+ assert convex.polar_second_moment_of_area() == 5*sqrt(3)/S(8)
+
+ concave = Polygon((0, 0), (1, 8), (3, 4), (4, 6), (7, 1))
+ assert concave.section_modulus() == (Rational(-6371, 429), Rational(-9778, 519))
+ assert concave.polar_second_moment_of_area() == Rational(-38669, 252)
+
+
+def test_cut_section():
+ # concave polygon
+ p = Polygon((-1, -1), (1, Rational(5, 2)), (2, 1), (3, Rational(5, 2)), (4, 2), (5, 3), (-1, 3))
+ l = Line((0, 0), (Rational(9, 2), 3))
+ p1 = p.cut_section(l)[0]
+ p2 = p.cut_section(l)[1]
+ assert p1 == Polygon(
+ Point2D(Rational(-9, 13), Rational(-6, 13)), Point2D(1, Rational(5, 2)), Point2D(Rational(24, 13), Rational(16, 13)),
+ Point2D(Rational(12, 5), Rational(8, 5)), Point2D(3, Rational(5, 2)), Point2D(Rational(24, 7), Rational(16, 7)),
+ Point2D(Rational(9, 2), 3), Point2D(-1, 3), Point2D(-1, Rational(-2, 3)))
+ assert p2 == Polygon(Point2D(-1, -1), Point2D(Rational(-9, 13), Rational(-6, 13)), Point2D(Rational(24, 13), Rational(16, 13)),
+ Point2D(2, 1), Point2D(Rational(12, 5), Rational(8, 5)), Point2D(Rational(24, 7), Rational(16, 7)), Point2D(4, 2), Point2D(5, 3),
+ Point2D(Rational(9, 2), 3), Point2D(-1, Rational(-2, 3)))
+
+ # convex polygon
+ p = RegularPolygon(Point2D(0, 0), 6, 6)
+ s = p.cut_section(Line((0, 0), slope=1))
+ assert s[0] == Polygon(Point2D(-3*sqrt(3) + 9, -3*sqrt(3) + 9), Point2D(3, 3*sqrt(3)),
+ Point2D(-3, 3*sqrt(3)), Point2D(-6, 0), Point2D(-9 + 3*sqrt(3), -9 + 3*sqrt(3)))
+ assert s[1] == Polygon(Point2D(6, 0), Point2D(-3*sqrt(3) + 9, -3*sqrt(3) + 9),
+ Point2D(-9 + 3*sqrt(3), -9 + 3*sqrt(3)), Point2D(-3, -3*sqrt(3)), Point2D(3, -3*sqrt(3)))
+
+ # case where line does not intersects but coincides with the edge of polygon
+ a, b = 20, 10
+ t1, t2, t3, t4 = [(0, b), (0, 0), (a, 0), (a, b)]
+ p = Polygon(t1, t2, t3, t4)
+ p1, p2 = p.cut_section(Line((0, b), slope=0))
+ assert p1 == None
+ assert p2 == Polygon(Point2D(0, 10), Point2D(0, 0), Point2D(20, 0), Point2D(20, 10))
+
+ p3, p4 = p.cut_section(Line((0, 0), slope=0))
+ assert p3 == Polygon(Point2D(0, 10), Point2D(0, 0), Point2D(20, 0), Point2D(20, 10))
+ assert p4 == None
+
+ # case where the line does not intersect with a polygon at all
+ raises(ValueError, lambda: p.cut_section(Line((0, a), slope=0)))
+
+def test_type_of_triangle():
+ # Isoceles triangle
+ p1 = Polygon(Point(0, 0), Point(5, 0), Point(2, 4))
+ assert p1.is_isosceles() == True
+ assert p1.is_scalene() == False
+ assert p1.is_equilateral() == False
+
+ # Scalene triangle
+ p2 = Polygon (Point(0, 0), Point(0, 2), Point(4, 0))
+ assert p2.is_isosceles() == False
+ assert p2.is_scalene() == True
+ assert p2.is_equilateral() == False
+
+ # Equilateral triagle
+ p3 = Polygon(Point(0, 0), Point(6, 0), Point(3, sqrt(27)))
+ assert p3.is_isosceles() == True
+ assert p3.is_scalene() == False
+ assert p3.is_equilateral() == True
+
+def test_do_poly_distance():
+ # Non-intersecting polygons
+ square1 = Polygon (Point(0, 0), Point(0, 1), Point(1, 1), Point(1, 0))
+ triangle1 = Polygon(Point(1, 2), Point(2, 2), Point(2, 1))
+ assert square1._do_poly_distance(triangle1) == sqrt(2)/2
+
+ # Polygons which sides intersect
+ square2 = Polygon(Point(1, 0), Point(2, 0), Point(2, 1), Point(1, 1))
+ with warns(UserWarning, \
+ match="Polygons may intersect producing erroneous output", test_stacklevel=False):
+ assert square1._do_poly_distance(square2) == 0
+
+ # Polygons which bodies intersect
+ triangle2 = Polygon(Point(0, -1), Point(2, -1), Point(S.Half, S.Half))
+ with warns(UserWarning, \
+ match="Polygons may intersect producing erroneous output", test_stacklevel=False):
+ assert triangle2._do_poly_distance(square1) == 0
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..10c0b89406f7d3a1d4ced651325e4f80223166ca
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/__init__.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/combsimp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/combsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9682c42e56c601f8a0ad950fbd0d122bf0913917
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/combsimp.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/cse_main.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/cse_main.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05d4fec3049be70c6e23e3c92d30dc9826c9b26d
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/cse_main.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/cse_opts.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/cse_opts.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a0967fe907a5d53de7cb0cb35a15c53fbad3ee6e
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/cse_opts.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/epathtools.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/epathtools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8103bf57e77f9776e72733991f2c94d5e90cc680
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/epathtools.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/fu.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/fu.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c585c0fc15c46b0829ecd0788324765a86e1e673
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/fu.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/gammasimp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/gammasimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c1860bb6479bf42f3593ee00a04faf774d55004c
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/gammasimp.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/hyperexpand.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/hyperexpand.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5941fc2fe30354857f3f6f82ec06a42d92476e4d
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/hyperexpand.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/hyperexpand_doc.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/hyperexpand_doc.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..768d168738ef37fb18d3e8884f249bfb3f0e24e6
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/hyperexpand_doc.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/powsimp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/powsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1cb44abd958d165036bb2ffb0a0cd1ad73aa5fc3
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/powsimp.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/radsimp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/radsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d8f597d52f62a65b39853d474c25a6e38e98d744
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/radsimp.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/ratsimp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/ratsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bb31785d40cfde8c144bb4c1fa2097b649237c57
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/ratsimp.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/simplify.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/simplify.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f4885d66c3f960f356eb5ab6aa7e5196cc7fe42a
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/simplify.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/sqrtdenest.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/sqrtdenest.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8448d6933c44256468f66272d15226437f27f97a
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/sqrtdenest.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/traversaltools.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/traversaltools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8cf4330bde5998476cc0e4920a2ba78881fa4cb5
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/traversaltools.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/trigsimp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/trigsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..437dd1c924a3caf7f9aabddc455b0fe75fe7448a
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/__pycache__/trigsimp.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/hyperexpand.py b/vllm/lib/python3.10/site-packages/sympy/simplify/hyperexpand.py
new file mode 100644
index 0000000000000000000000000000000000000000..111dd1dd01f268f4fa7e32e174670c37f17716ca
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/hyperexpand.py
@@ -0,0 +1,2494 @@
+"""
+Expand Hypergeometric (and Meijer G) functions into named
+special functions.
+
+The algorithm for doing this uses a collection of lookup tables of
+hypergeometric functions, and various of their properties, to expand
+many hypergeometric functions in terms of special functions.
+
+It is based on the following paper:
+ Kelly B. Roach. Meijer G Function Representations.
+ In: Proceedings of the 1997 International Symposium on Symbolic and
+ Algebraic Computation, pages 205-211, New York, 1997. ACM.
+
+It is described in great(er) detail in the Sphinx documentation.
+"""
+# SUMMARY OF EXTENSIONS FOR MEIJER G FUNCTIONS
+#
+# o z**rho G(ap, bq; z) = G(ap + rho, bq + rho; z)
+#
+# o denote z*d/dz by D
+#
+# o It is helpful to keep in mind that ap and bq play essentially symmetric
+# roles: G(1/z) has slightly altered parameters, with ap and bq interchanged.
+#
+# o There are four shift operators:
+# A_J = b_J - D, J = 1, ..., n
+# B_J = 1 - a_j + D, J = 1, ..., m
+# C_J = -b_J + D, J = m+1, ..., q
+# D_J = a_J - 1 - D, J = n+1, ..., p
+#
+# A_J, C_J increment b_J
+# B_J, D_J decrement a_J
+#
+# o The corresponding four inverse-shift operators are defined if there
+# is no cancellation. Thus e.g. an index a_J (upper or lower) can be
+# incremented if a_J != b_i for i = 1, ..., q.
+#
+# o Order reduction: if b_j - a_i is a non-negative integer, where
+# j <= m and i > n, the corresponding quotient of gamma functions reduces
+# to a polynomial. Hence the G function can be expressed using a G-function
+# of lower order.
+# Similarly if j > m and i <= n.
+#
+# Secondly, there are paired index theorems [Adamchik, The evaluation of
+# integrals of Bessel functions via G-function identities]. Suppose there
+# are three parameters a, b, c, where a is an a_i, i <= n, b is a b_j,
+# j <= m and c is a denominator parameter (i.e. a_i, i > n or b_j, j > m).
+# Suppose further all three differ by integers.
+# Then the order can be reduced.
+# TODO work this out in detail.
+#
+# o An index quadruple is called suitable if its order cannot be reduced.
+# If there exists a sequence of shift operators transforming one index
+# quadruple into another, we say one is reachable from the other.
+#
+# o Deciding if one index quadruple is reachable from another is tricky. For
+# this reason, we use hand-built routines to match and instantiate formulas.
+#
+from collections import defaultdict
+from itertools import product
+from functools import reduce
+from math import prod
+
+from sympy import SYMPY_DEBUG
+from sympy.core import (S, Dummy, symbols, sympify, Tuple, expand, I, pi, Mul,
+ EulerGamma, oo, zoo, expand_func, Add, nan, Expr, Rational)
+from sympy.core.mod import Mod
+from sympy.core.sorting import default_sort_key
+from sympy.functions import (exp, sqrt, root, log, lowergamma, cos,
+ besseli, gamma, uppergamma, expint, erf, sin, besselj, Ei, Ci, Si, Shi,
+ sinh, cosh, Chi, fresnels, fresnelc, polar_lift, exp_polar, floor, ceiling,
+ rf, factorial, lerchphi, Piecewise, re, elliptic_k, elliptic_e)
+from sympy.functions.elementary.complexes import polarify, unpolarify
+from sympy.functions.special.hyper import (hyper, HyperRep_atanh,
+ HyperRep_power1, HyperRep_power2, HyperRep_log1, HyperRep_asin1,
+ HyperRep_asin2, HyperRep_sqrts1, HyperRep_sqrts2, HyperRep_log2,
+ HyperRep_cosasin, HyperRep_sinasin, meijerg)
+from sympy.matrices import Matrix, eye, zeros
+from sympy.polys import apart, poly, Poly
+from sympy.series import residue
+from sympy.simplify.powsimp import powdenest
+from sympy.utilities.iterables import sift
+
+# function to define "buckets"
+def _mod1(x):
+ # TODO see if this can work as Mod(x, 1); this will require
+ # different handling of the "buckets" since these need to
+ # be sorted and that fails when there is a mixture of
+ # integers and expressions with parameters. With the current
+ # Mod behavior, Mod(k, 1) == Mod(1, 1) == 0 if k is an integer.
+ # Although the sorting can be done with Basic.compare, this may
+ # still require different handling of the sorted buckets.
+ if x.is_Number:
+ return Mod(x, 1)
+ c, x = x.as_coeff_Add()
+ return Mod(c, 1) + x
+
+
+# leave add formulae at the top for easy reference
+def add_formulae(formulae):
+ """ Create our knowledge base. """
+ a, b, c, z = symbols('a b c, z', cls=Dummy)
+
+ def add(ap, bq, res):
+ func = Hyper_Function(ap, bq)
+ formulae.append(Formula(func, z, res, (a, b, c)))
+
+ def addb(ap, bq, B, C, M):
+ func = Hyper_Function(ap, bq)
+ formulae.append(Formula(func, z, None, (a, b, c), B, C, M))
+
+ # Luke, Y. L. (1969), The Special Functions and Their Approximations,
+ # Volume 1, section 6.2
+
+ # 0F0
+ add((), (), exp(z))
+
+ # 1F0
+ add((a, ), (), HyperRep_power1(-a, z))
+
+ # 2F1
+ addb((a, a - S.Half), (2*a, ),
+ Matrix([HyperRep_power2(a, z),
+ HyperRep_power2(a + S.Half, z)/2]),
+ Matrix([[1, 0]]),
+ Matrix([[(a - S.Half)*z/(1 - z), (S.Half - a)*z/(1 - z)],
+ [a/(1 - z), a*(z - 2)/(1 - z)]]))
+ addb((1, 1), (2, ),
+ Matrix([HyperRep_log1(z), 1]), Matrix([[-1/z, 0]]),
+ Matrix([[0, z/(z - 1)], [0, 0]]))
+ addb((S.Half, 1), (S('3/2'), ),
+ Matrix([HyperRep_atanh(z), 1]),
+ Matrix([[1, 0]]),
+ Matrix([[Rational(-1, 2), 1/(1 - z)/2], [0, 0]]))
+ addb((S.Half, S.Half), (S('3/2'), ),
+ Matrix([HyperRep_asin1(z), HyperRep_power1(Rational(-1, 2), z)]),
+ Matrix([[1, 0]]),
+ Matrix([[Rational(-1, 2), S.Half], [0, z/(1 - z)/2]]))
+ addb((a, S.Half + a), (S.Half, ),
+ Matrix([HyperRep_sqrts1(-a, z), -HyperRep_sqrts2(-a - S.Half, z)]),
+ Matrix([[1, 0]]),
+ Matrix([[0, -a],
+ [z*(-2*a - 1)/2/(1 - z), S.Half - z*(-2*a - 1)/(1 - z)]]))
+
+ # A. P. Prudnikov, Yu. A. Brychkov and O. I. Marichev (1990).
+ # Integrals and Series: More Special Functions, Vol. 3,.
+ # Gordon and Breach Science Publisher
+ addb([a, -a], [S.Half],
+ Matrix([HyperRep_cosasin(a, z), HyperRep_sinasin(a, z)]),
+ Matrix([[1, 0]]),
+ Matrix([[0, -a], [a*z/(1 - z), 1/(1 - z)/2]]))
+ addb([1, 1], [3*S.Half],
+ Matrix([HyperRep_asin2(z), 1]), Matrix([[1, 0]]),
+ Matrix([[(z - S.Half)/(1 - z), 1/(1 - z)/2], [0, 0]]))
+
+ # Complete elliptic integrals K(z) and E(z), both a 2F1 function
+ addb([S.Half, S.Half], [S.One],
+ Matrix([elliptic_k(z), elliptic_e(z)]),
+ Matrix([[2/pi, 0]]),
+ Matrix([[Rational(-1, 2), -1/(2*z-2)],
+ [Rational(-1, 2), S.Half]]))
+ addb([Rational(-1, 2), S.Half], [S.One],
+ Matrix([elliptic_k(z), elliptic_e(z)]),
+ Matrix([[0, 2/pi]]),
+ Matrix([[Rational(-1, 2), -1/(2*z-2)],
+ [Rational(-1, 2), S.Half]]))
+
+ # 3F2
+ addb([Rational(-1, 2), 1, 1], [S.Half, 2],
+ Matrix([z*HyperRep_atanh(z), HyperRep_log1(z), 1]),
+ Matrix([[Rational(-2, 3), -S.One/(3*z), Rational(2, 3)]]),
+ Matrix([[S.Half, 0, z/(1 - z)/2],
+ [0, 0, z/(z - 1)],
+ [0, 0, 0]]))
+ # actually the formula for 3/2 is much nicer ...
+ addb([Rational(-1, 2), 1, 1], [2, 2],
+ Matrix([HyperRep_power1(S.Half, z), HyperRep_log2(z), 1]),
+ Matrix([[Rational(4, 9) - 16/(9*z), 4/(3*z), 16/(9*z)]]),
+ Matrix([[z/2/(z - 1), 0, 0], [1/(2*(z - 1)), 0, S.Half], [0, 0, 0]]))
+
+ # 1F1
+ addb([1], [b], Matrix([z**(1 - b) * exp(z) * lowergamma(b - 1, z), 1]),
+ Matrix([[b - 1, 0]]), Matrix([[1 - b + z, 1], [0, 0]]))
+ addb([a], [2*a],
+ Matrix([z**(S.Half - a)*exp(z/2)*besseli(a - S.Half, z/2)
+ * gamma(a + S.Half)/4**(S.Half - a),
+ z**(S.Half - a)*exp(z/2)*besseli(a + S.Half, z/2)
+ * gamma(a + S.Half)/4**(S.Half - a)]),
+ Matrix([[1, 0]]),
+ Matrix([[z/2, z/2], [z/2, (z/2 - 2*a)]]))
+ mz = polar_lift(-1)*z
+ addb([a], [a + 1],
+ Matrix([mz**(-a)*a*lowergamma(a, mz), a*exp(z)]),
+ Matrix([[1, 0]]),
+ Matrix([[-a, 1], [0, z]]))
+ # This one is redundant.
+ add([Rational(-1, 2)], [S.Half], exp(z) - sqrt(pi*z)*(-I)*erf(I*sqrt(z)))
+
+ # Added to get nice results for Laplace transform of Fresnel functions
+ # https://functions.wolfram.com/07.22.03.6437.01
+ # Basic rule
+ #add([1], [Rational(3, 4), Rational(5, 4)],
+ # sqrt(pi) * (cos(2*sqrt(polar_lift(-1)*z))*fresnelc(2*root(polar_lift(-1)*z,4)/sqrt(pi)) +
+ # sin(2*sqrt(polar_lift(-1)*z))*fresnels(2*root(polar_lift(-1)*z,4)/sqrt(pi)))
+ # / (2*root(polar_lift(-1)*z,4)))
+ # Manually tuned rule
+ addb([1], [Rational(3, 4), Rational(5, 4)],
+ Matrix([ sqrt(pi)*(I*sinh(2*sqrt(z))*fresnels(2*root(z, 4)*exp(I*pi/4)/sqrt(pi))
+ + cosh(2*sqrt(z))*fresnelc(2*root(z, 4)*exp(I*pi/4)/sqrt(pi)))
+ * exp(-I*pi/4)/(2*root(z, 4)),
+ sqrt(pi)*root(z, 4)*(sinh(2*sqrt(z))*fresnelc(2*root(z, 4)*exp(I*pi/4)/sqrt(pi))
+ + I*cosh(2*sqrt(z))*fresnels(2*root(z, 4)*exp(I*pi/4)/sqrt(pi)))
+ *exp(-I*pi/4)/2,
+ 1 ]),
+ Matrix([[1, 0, 0]]),
+ Matrix([[Rational(-1, 4), 1, Rational(1, 4)],
+ [ z, Rational(1, 4), 0],
+ [ 0, 0, 0]]))
+
+ # 2F2
+ addb([S.Half, a], [Rational(3, 2), a + 1],
+ Matrix([a/(2*a - 1)*(-I)*sqrt(pi/z)*erf(I*sqrt(z)),
+ a/(2*a - 1)*(polar_lift(-1)*z)**(-a)*
+ lowergamma(a, polar_lift(-1)*z),
+ a/(2*a - 1)*exp(z)]),
+ Matrix([[1, -1, 0]]),
+ Matrix([[Rational(-1, 2), 0, 1], [0, -a, 1], [0, 0, z]]))
+ # We make a "basis" of four functions instead of three, and give EulerGamma
+ # an extra slot (it could just be a coefficient to 1). The advantage is
+ # that this way Polys will not see multivariate polynomials (it treats
+ # EulerGamma as an indeterminate), which is *way* faster.
+ addb([1, 1], [2, 2],
+ Matrix([Ei(z) - log(z), exp(z), 1, EulerGamma]),
+ Matrix([[1/z, 0, 0, -1/z]]),
+ Matrix([[0, 1, -1, 0], [0, z, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]))
+
+ # 0F1
+ add((), (S.Half, ), cosh(2*sqrt(z)))
+ addb([], [b],
+ Matrix([gamma(b)*z**((1 - b)/2)*besseli(b - 1, 2*sqrt(z)),
+ gamma(b)*z**(1 - b/2)*besseli(b, 2*sqrt(z))]),
+ Matrix([[1, 0]]), Matrix([[0, 1], [z, (1 - b)]]))
+
+ # 0F3
+ x = 4*z**Rational(1, 4)
+
+ def fp(a, z):
+ return besseli(a, x) + besselj(a, x)
+
+ def fm(a, z):
+ return besseli(a, x) - besselj(a, x)
+
+ # TODO branching
+ addb([], [S.Half, a, a + S.Half],
+ Matrix([fp(2*a - 1, z), fm(2*a, z)*z**Rational(1, 4),
+ fm(2*a - 1, z)*sqrt(z), fp(2*a, z)*z**Rational(3, 4)])
+ * 2**(-2*a)*gamma(2*a)*z**((1 - 2*a)/4),
+ Matrix([[1, 0, 0, 0]]),
+ Matrix([[0, 1, 0, 0],
+ [0, S.Half - a, 1, 0],
+ [0, 0, S.Half, 1],
+ [z, 0, 0, 1 - a]]))
+ x = 2*(4*z)**Rational(1, 4)*exp_polar(I*pi/4)
+ addb([], [a, a + S.Half, 2*a],
+ (2*sqrt(polar_lift(-1)*z))**(1 - 2*a)*gamma(2*a)**2 *
+ Matrix([besselj(2*a - 1, x)*besseli(2*a - 1, x),
+ x*(besseli(2*a, x)*besselj(2*a - 1, x)
+ - besseli(2*a - 1, x)*besselj(2*a, x)),
+ x**2*besseli(2*a, x)*besselj(2*a, x),
+ x**3*(besseli(2*a, x)*besselj(2*a - 1, x)
+ + besseli(2*a - 1, x)*besselj(2*a, x))]),
+ Matrix([[1, 0, 0, 0]]),
+ Matrix([[0, Rational(1, 4), 0, 0],
+ [0, (1 - 2*a)/2, Rational(-1, 2), 0],
+ [0, 0, 1 - 2*a, Rational(1, 4)],
+ [-32*z, 0, 0, 1 - a]]))
+
+ # 1F2
+ addb([a], [a - S.Half, 2*a],
+ Matrix([z**(S.Half - a)*besseli(a - S.Half, sqrt(z))**2,
+ z**(1 - a)*besseli(a - S.Half, sqrt(z))
+ *besseli(a - Rational(3, 2), sqrt(z)),
+ z**(Rational(3, 2) - a)*besseli(a - Rational(3, 2), sqrt(z))**2]),
+ Matrix([[-gamma(a + S.Half)**2/4**(S.Half - a),
+ 2*gamma(a - S.Half)*gamma(a + S.Half)/4**(1 - a),
+ 0]]),
+ Matrix([[1 - 2*a, 1, 0], [z/2, S.Half - a, S.Half], [0, z, 0]]))
+ addb([S.Half], [b, 2 - b],
+ pi*(1 - b)/sin(pi*b)*
+ Matrix([besseli(1 - b, sqrt(z))*besseli(b - 1, sqrt(z)),
+ sqrt(z)*(besseli(-b, sqrt(z))*besseli(b - 1, sqrt(z))
+ + besseli(1 - b, sqrt(z))*besseli(b, sqrt(z))),
+ besseli(-b, sqrt(z))*besseli(b, sqrt(z))]),
+ Matrix([[1, 0, 0]]),
+ Matrix([[b - 1, S.Half, 0],
+ [z, 0, z],
+ [0, S.Half, -b]]))
+ addb([S.Half], [Rational(3, 2), Rational(3, 2)],
+ Matrix([Shi(2*sqrt(z))/2/sqrt(z), sinh(2*sqrt(z))/2/sqrt(z),
+ cosh(2*sqrt(z))]),
+ Matrix([[1, 0, 0]]),
+ Matrix([[Rational(-1, 2), S.Half, 0], [0, Rational(-1, 2), S.Half], [0, 2*z, 0]]))
+
+ # FresnelS
+ # Basic rule
+ #add([Rational(3, 4)], [Rational(3, 2),Rational(7, 4)], 6*fresnels( exp(pi*I/4)*root(z,4)*2/sqrt(pi) ) / ( pi * (exp(pi*I/4)*root(z,4)*2/sqrt(pi))**3 ) )
+ # Manually tuned rule
+ addb([Rational(3, 4)], [Rational(3, 2), Rational(7, 4)],
+ Matrix(
+ [ fresnels(
+ exp(
+ pi*I/4)*root(
+ z, 4)*2/sqrt(
+ pi) ) / (
+ pi * (exp(pi*I/4)*root(z, 4)*2/sqrt(pi))**3 ),
+ sinh(2*sqrt(z))/sqrt(z),
+ cosh(2*sqrt(z)) ]),
+ Matrix([[6, 0, 0]]),
+ Matrix([[Rational(-3, 4), Rational(1, 16), 0],
+ [ 0, Rational(-1, 2), 1],
+ [ 0, z, 0]]))
+
+ # FresnelC
+ # Basic rule
+ #add([Rational(1, 4)], [S.Half,Rational(5, 4)], fresnelc( exp(pi*I/4)*root(z,4)*2/sqrt(pi) ) / ( exp(pi*I/4)*root(z,4)*2/sqrt(pi) ) )
+ # Manually tuned rule
+ addb([Rational(1, 4)], [S.Half, Rational(5, 4)],
+ Matrix(
+ [ sqrt(
+ pi)*exp(
+ -I*pi/4)*fresnelc(
+ 2*root(z, 4)*exp(I*pi/4)/sqrt(pi))/(2*root(z, 4)),
+ cosh(2*sqrt(z)),
+ sinh(2*sqrt(z))*sqrt(z) ]),
+ Matrix([[1, 0, 0]]),
+ Matrix([[Rational(-1, 4), Rational(1, 4), 0 ],
+ [ 0, 0, 1 ],
+ [ 0, z, S.Half]]))
+
+ # 2F3
+ # XXX with this five-parameter formula is pretty slow with the current
+ # Formula.find_instantiations (creates 2!*3!*3**(2+3) ~ 3000
+ # instantiations ... But it's not too bad.
+ addb([a, a + S.Half], [2*a, b, 2*a - b + 1],
+ gamma(b)*gamma(2*a - b + 1) * (sqrt(z)/2)**(1 - 2*a) *
+ Matrix([besseli(b - 1, sqrt(z))*besseli(2*a - b, sqrt(z)),
+ sqrt(z)*besseli(b, sqrt(z))*besseli(2*a - b, sqrt(z)),
+ sqrt(z)*besseli(b - 1, sqrt(z))*besseli(2*a - b + 1, sqrt(z)),
+ besseli(b, sqrt(z))*besseli(2*a - b + 1, sqrt(z))]),
+ Matrix([[1, 0, 0, 0]]),
+ Matrix([[0, S.Half, S.Half, 0],
+ [z/2, 1 - b, 0, z/2],
+ [z/2, 0, b - 2*a, z/2],
+ [0, S.Half, S.Half, -2*a]]))
+ # (C/f above comment about eulergamma in the basis).
+ addb([1, 1], [2, 2, Rational(3, 2)],
+ Matrix([Chi(2*sqrt(z)) - log(2*sqrt(z)),
+ cosh(2*sqrt(z)), sqrt(z)*sinh(2*sqrt(z)), 1, EulerGamma]),
+ Matrix([[1/z, 0, 0, 0, -1/z]]),
+ Matrix([[0, S.Half, 0, Rational(-1, 2), 0],
+ [0, 0, 1, 0, 0],
+ [0, z, S.Half, 0, 0],
+ [0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0]]))
+
+ # 3F3
+ # This is rule: https://functions.wolfram.com/07.31.03.0134.01
+ # Initial reason to add it was a nice solution for
+ # integrate(erf(a*z)/z**2, z) and same for erfc and erfi.
+ # Basic rule
+ # add([1, 1, a], [2, 2, a+1], (a/(z*(a-1)**2)) *
+ # (1 - (-z)**(1-a) * (gamma(a) - uppergamma(a,-z))
+ # - (a-1) * (EulerGamma + uppergamma(0,-z) + log(-z))
+ # - exp(z)))
+ # Manually tuned rule
+ addb([1, 1, a], [2, 2, a+1],
+ Matrix([a*(log(-z) + expint(1, -z) + EulerGamma)/(z*(a**2 - 2*a + 1)),
+ a*(-z)**(-a)*(gamma(a) - uppergamma(a, -z))/(a - 1)**2,
+ a*exp(z)/(a**2 - 2*a + 1),
+ a/(z*(a**2 - 2*a + 1))]),
+ Matrix([[1-a, 1, -1/z, 1]]),
+ Matrix([[-1,0,-1/z,1],
+ [0,-a,1,0],
+ [0,0,z,0],
+ [0,0,0,-1]]))
+
+
+def add_meijerg_formulae(formulae):
+ a, b, c, z = list(map(Dummy, 'abcz'))
+ rho = Dummy('rho')
+
+ def add(an, ap, bm, bq, B, C, M, matcher):
+ formulae.append(MeijerFormula(an, ap, bm, bq, z, [a, b, c, rho],
+ B, C, M, matcher))
+
+ def detect_uppergamma(func):
+ x = func.an[0]
+ y, z = func.bm
+ swapped = False
+ if not _mod1((x - y).simplify()):
+ swapped = True
+ (y, z) = (z, y)
+ if _mod1((x - z).simplify()) or x - z > 0:
+ return None
+ l = [y, x]
+ if swapped:
+ l = [x, y]
+ return {rho: y, a: x - y}, G_Function([x], [], l, [])
+
+ add([a + rho], [], [rho, a + rho], [],
+ Matrix([gamma(1 - a)*z**rho*exp(z)*uppergamma(a, z),
+ gamma(1 - a)*z**(a + rho)]),
+ Matrix([[1, 0]]),
+ Matrix([[rho + z, -1], [0, a + rho]]),
+ detect_uppergamma)
+
+ def detect_3113(func):
+ """https://functions.wolfram.com/07.34.03.0984.01"""
+ x = func.an[0]
+ u, v, w = func.bm
+ if _mod1((u - v).simplify()) == 0:
+ if _mod1((v - w).simplify()) == 0:
+ return
+ sig = (S.Half, S.Half, S.Zero)
+ x1, x2, y = u, v, w
+ else:
+ if _mod1((x - u).simplify()) == 0:
+ sig = (S.Half, S.Zero, S.Half)
+ x1, y, x2 = u, v, w
+ else:
+ sig = (S.Zero, S.Half, S.Half)
+ y, x1, x2 = u, v, w
+
+ if (_mod1((x - x1).simplify()) != 0 or
+ _mod1((x - x2).simplify()) != 0 or
+ _mod1((x - y).simplify()) != S.Half or
+ x - x1 > 0 or x - x2 > 0):
+ return
+
+ return {a: x}, G_Function([x], [], [x - S.Half + t for t in sig], [])
+
+ s = sin(2*sqrt(z))
+ c_ = cos(2*sqrt(z))
+ S_ = Si(2*sqrt(z)) - pi/2
+ C = Ci(2*sqrt(z))
+ add([a], [], [a, a, a - S.Half], [],
+ Matrix([sqrt(pi)*z**(a - S.Half)*(c_*S_ - s*C),
+ sqrt(pi)*z**a*(s*S_ + c_*C),
+ sqrt(pi)*z**a]),
+ Matrix([[-2, 0, 0]]),
+ Matrix([[a - S.Half, -1, 0], [z, a, S.Half], [0, 0, a]]),
+ detect_3113)
+
+
+def make_simp(z):
+ """ Create a function that simplifies rational functions in ``z``. """
+
+ def simp(expr):
+ """ Efficiently simplify the rational function ``expr``. """
+ numer, denom = expr.as_numer_denom()
+ numer = numer.expand()
+ # denom = denom.expand() # is this needed?
+ c, numer, denom = poly(numer, z).cancel(poly(denom, z))
+ return c * numer.as_expr() / denom.as_expr()
+
+ return simp
+
+
+def debug(*args):
+ if SYMPY_DEBUG:
+ for a in args:
+ print(a, end="")
+ print()
+
+
+class Hyper_Function(Expr):
+ """ A generalized hypergeometric function. """
+
+ def __new__(cls, ap, bq):
+ obj = super().__new__(cls)
+ obj.ap = Tuple(*list(map(expand, ap)))
+ obj.bq = Tuple(*list(map(expand, bq)))
+ return obj
+
+ @property
+ def args(self):
+ return (self.ap, self.bq)
+
+ @property
+ def sizes(self):
+ return (len(self.ap), len(self.bq))
+
+ @property
+ def gamma(self):
+ """
+ Number of upper parameters that are negative integers
+
+ This is a transformation invariant.
+ """
+ return sum(bool(x.is_integer and x.is_negative) for x in self.ap)
+
+ def _hashable_content(self):
+ return super()._hashable_content() + (self.ap,
+ self.bq)
+
+ def __call__(self, arg):
+ return hyper(self.ap, self.bq, arg)
+
+ def build_invariants(self):
+ """
+ Compute the invariant vector.
+
+ Explanation
+ ===========
+
+ The invariant vector is:
+ (gamma, ((s1, n1), ..., (sk, nk)), ((t1, m1), ..., (tr, mr)))
+ where gamma is the number of integer a < 0,
+ s1 < ... < sk
+ nl is the number of parameters a_i congruent to sl mod 1
+ t1 < ... < tr
+ ml is the number of parameters b_i congruent to tl mod 1
+
+ If the index pair contains parameters, then this is not truly an
+ invariant, since the parameters cannot be sorted uniquely mod1.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.hyperexpand import Hyper_Function
+ >>> from sympy import S
+ >>> ap = (S.Half, S.One/3, S(-1)/2, -2)
+ >>> bq = (1, 2)
+
+ Here gamma = 1,
+ k = 3, s1 = 0, s2 = 1/3, s3 = 1/2
+ n1 = 1, n2 = 1, n2 = 2
+ r = 1, t1 = 0
+ m1 = 2:
+
+ >>> Hyper_Function(ap, bq).build_invariants()
+ (1, ((0, 1), (1/3, 1), (1/2, 2)), ((0, 2),))
+ """
+ abuckets, bbuckets = sift(self.ap, _mod1), sift(self.bq, _mod1)
+
+ def tr(bucket):
+ bucket = list(bucket.items())
+ if not any(isinstance(x[0], Mod) for x in bucket):
+ bucket.sort(key=lambda x: default_sort_key(x[0]))
+ bucket = tuple([(mod, len(values)) for mod, values in bucket if
+ values])
+ return bucket
+
+ return (self.gamma, tr(abuckets), tr(bbuckets))
+
+ def difficulty(self, func):
+ """ Estimate how many steps it takes to reach ``func`` from self.
+ Return -1 if impossible. """
+ if self.gamma != func.gamma:
+ return -1
+ oabuckets, obbuckets, abuckets, bbuckets = [sift(params, _mod1) for
+ params in (self.ap, self.bq, func.ap, func.bq)]
+
+ diff = 0
+ for bucket, obucket in [(abuckets, oabuckets), (bbuckets, obbuckets)]:
+ for mod in set(list(bucket.keys()) + list(obucket.keys())):
+ if (mod not in bucket) or (mod not in obucket) \
+ or len(bucket[mod]) != len(obucket[mod]):
+ return -1
+ l1 = list(bucket[mod])
+ l2 = list(obucket[mod])
+ l1.sort()
+ l2.sort()
+ for i, j in zip(l1, l2):
+ diff += abs(i - j)
+
+ return diff
+
+ def _is_suitable_origin(self):
+ """
+ Decide if ``self`` is a suitable origin.
+
+ Explanation
+ ===========
+
+ A function is a suitable origin iff:
+ * none of the ai equals bj + n, with n a non-negative integer
+ * none of the ai is zero
+ * none of the bj is a non-positive integer
+
+ Note that this gives meaningful results only when none of the indices
+ are symbolic.
+
+ """
+ for a in self.ap:
+ for b in self.bq:
+ if (a - b).is_integer and (a - b).is_negative is False:
+ return False
+ for a in self.ap:
+ if a == 0:
+ return False
+ for b in self.bq:
+ if b.is_integer and b.is_nonpositive:
+ return False
+ return True
+
+
+class G_Function(Expr):
+ """ A Meijer G-function. """
+
+ def __new__(cls, an, ap, bm, bq):
+ obj = super().__new__(cls)
+ obj.an = Tuple(*list(map(expand, an)))
+ obj.ap = Tuple(*list(map(expand, ap)))
+ obj.bm = Tuple(*list(map(expand, bm)))
+ obj.bq = Tuple(*list(map(expand, bq)))
+ return obj
+
+ @property
+ def args(self):
+ return (self.an, self.ap, self.bm, self.bq)
+
+ def _hashable_content(self):
+ return super()._hashable_content() + self.args
+
+ def __call__(self, z):
+ return meijerg(self.an, self.ap, self.bm, self.bq, z)
+
+ def compute_buckets(self):
+ """
+ Compute buckets for the fours sets of parameters.
+
+ Explanation
+ ===========
+
+ We guarantee that any two equal Mod objects returned are actually the
+ same, and that the buckets are sorted by real part (an and bq
+ descendending, bm and ap ascending).
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.hyperexpand import G_Function
+ >>> from sympy.abc import y
+ >>> from sympy import S
+
+ >>> a, b = [1, 3, 2, S(3)/2], [1 + y, y, 2, y + 3]
+ >>> G_Function(a, b, [2], [y]).compute_buckets()
+ ({0: [3, 2, 1], 1/2: [3/2]},
+ {0: [2], y: [y, y + 1, y + 3]}, {0: [2]}, {y: [y]})
+
+ """
+ dicts = pan, pap, pbm, pbq = [defaultdict(list) for i in range(4)]
+ for dic, lis in zip(dicts, (self.an, self.ap, self.bm, self.bq)):
+ for x in lis:
+ dic[_mod1(x)].append(x)
+
+ for dic, flip in zip(dicts, (True, False, False, True)):
+ for m, items in dic.items():
+ x0 = items[0]
+ items.sort(key=lambda x: x - x0, reverse=flip)
+ dic[m] = items
+
+ return tuple([dict(w) for w in dicts])
+
+ @property
+ def signature(self):
+ return (len(self.an), len(self.ap), len(self.bm), len(self.bq))
+
+
+# Dummy variable.
+_x = Dummy('x')
+
+class Formula:
+ """
+ This class represents hypergeometric formulae.
+
+ Explanation
+ ===========
+
+ Its data members are:
+ - z, the argument
+ - closed_form, the closed form expression
+ - symbols, the free symbols (parameters) in the formula
+ - func, the function
+ - B, C, M (see _compute_basis)
+
+ Examples
+ ========
+
+ >>> from sympy.abc import a, b, z
+ >>> from sympy.simplify.hyperexpand import Formula, Hyper_Function
+ >>> func = Hyper_Function((a/2, a/3 + b, (1+a)/2), (a, b, (a+b)/7))
+ >>> f = Formula(func, z, None, [a, b])
+
+ """
+
+ def _compute_basis(self, closed_form):
+ """
+ Compute a set of functions B=(f1, ..., fn), a nxn matrix M
+ and a 1xn matrix C such that:
+ closed_form = C B
+ z d/dz B = M B.
+ """
+ afactors = [_x + a for a in self.func.ap]
+ bfactors = [_x + b - 1 for b in self.func.bq]
+ expr = _x*Mul(*bfactors) - self.z*Mul(*afactors)
+ poly = Poly(expr, _x)
+
+ n = poly.degree() - 1
+ b = [closed_form]
+ for _ in range(n):
+ b.append(self.z*b[-1].diff(self.z))
+
+ self.B = Matrix(b)
+ self.C = Matrix([[1] + [0]*n])
+
+ m = eye(n)
+ m = m.col_insert(0, zeros(n, 1))
+ l = poly.all_coeffs()[1:]
+ l.reverse()
+ self.M = m.row_insert(n, -Matrix([l])/poly.all_coeffs()[0])
+
+ def __init__(self, func, z, res, symbols, B=None, C=None, M=None):
+ z = sympify(z)
+ res = sympify(res)
+ symbols = [x for x in sympify(symbols) if func.has(x)]
+
+ self.z = z
+ self.symbols = symbols
+ self.B = B
+ self.C = C
+ self.M = M
+ self.func = func
+
+ # TODO with symbolic parameters, it could be advantageous
+ # (for prettier answers) to compute a basis only *after*
+ # instantiation
+ if res is not None:
+ self._compute_basis(res)
+
+ @property
+ def closed_form(self):
+ return reduce(lambda s,m: s+m[0]*m[1], zip(self.C, self.B), S.Zero)
+
+ def find_instantiations(self, func):
+ """
+ Find substitutions of the free symbols that match ``func``.
+
+ Return the substitution dictionaries as a list. Note that the returned
+ instantiations need not actually match, or be valid!
+
+ """
+ from sympy.solvers import solve
+ ap = func.ap
+ bq = func.bq
+ if len(ap) != len(self.func.ap) or len(bq) != len(self.func.bq):
+ raise TypeError('Cannot instantiate other number of parameters')
+ symbol_values = []
+ for a in self.symbols:
+ if a in self.func.ap.args:
+ symbol_values.append(ap)
+ elif a in self.func.bq.args:
+ symbol_values.append(bq)
+ else:
+ raise ValueError("At least one of the parameters of the "
+ "formula must be equal to %s" % (a,))
+ base_repl = [dict(list(zip(self.symbols, values)))
+ for values in product(*symbol_values)]
+ abuckets, bbuckets = [sift(params, _mod1) for params in [ap, bq]]
+ a_inv, b_inv = [{a: len(vals) for a, vals in bucket.items()}
+ for bucket in [abuckets, bbuckets]]
+ critical_values = [[0] for _ in self.symbols]
+ result = []
+ _n = Dummy()
+ for repl in base_repl:
+ symb_a, symb_b = [sift(params, lambda x: _mod1(x.xreplace(repl)))
+ for params in [self.func.ap, self.func.bq]]
+ for bucket, obucket in [(abuckets, symb_a), (bbuckets, symb_b)]:
+ for mod in set(list(bucket.keys()) + list(obucket.keys())):
+ if (mod not in bucket) or (mod not in obucket) \
+ or len(bucket[mod]) != len(obucket[mod]):
+ break
+ for a, vals in zip(self.symbols, critical_values):
+ if repl[a].free_symbols:
+ continue
+ exprs = [expr for expr in obucket[mod] if expr.has(a)]
+ repl0 = repl.copy()
+ repl0[a] += _n
+ for expr in exprs:
+ for target in bucket[mod]:
+ n0, = solve(expr.xreplace(repl0) - target, _n)
+ if n0.free_symbols:
+ raise ValueError("Value should not be true")
+ vals.append(n0)
+ else:
+ values = []
+ for a, vals in zip(self.symbols, critical_values):
+ a0 = repl[a]
+ min_ = floor(min(vals))
+ max_ = ceiling(max(vals))
+ values.append([a0 + n for n in range(min_, max_ + 1)])
+ result.extend(dict(list(zip(self.symbols, l))) for l in product(*values))
+ return result
+
+
+
+
+class FormulaCollection:
+ """ A collection of formulae to use as origins. """
+
+ def __init__(self):
+ """ Doing this globally at module init time is a pain ... """
+ self.symbolic_formulae = {}
+ self.concrete_formulae = {}
+ self.formulae = []
+
+ add_formulae(self.formulae)
+
+ # Now process the formulae into a helpful form.
+ # These dicts are indexed by (p, q).
+
+ for f in self.formulae:
+ sizes = f.func.sizes
+ if len(f.symbols) > 0:
+ self.symbolic_formulae.setdefault(sizes, []).append(f)
+ else:
+ inv = f.func.build_invariants()
+ self.concrete_formulae.setdefault(sizes, {})[inv] = f
+
+ def lookup_origin(self, func):
+ """
+ Given the suitable target ``func``, try to find an origin in our
+ knowledge base.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.hyperexpand import (FormulaCollection,
+ ... Hyper_Function)
+ >>> f = FormulaCollection()
+ >>> f.lookup_origin(Hyper_Function((), ())).closed_form
+ exp(_z)
+ >>> f.lookup_origin(Hyper_Function([1], ())).closed_form
+ HyperRep_power1(-1, _z)
+
+ >>> from sympy import S
+ >>> i = Hyper_Function([S('1/4'), S('3/4 + 4')], [S.Half])
+ >>> f.lookup_origin(i).closed_form
+ HyperRep_sqrts1(-1/4, _z)
+ """
+ inv = func.build_invariants()
+ sizes = func.sizes
+ if sizes in self.concrete_formulae and \
+ inv in self.concrete_formulae[sizes]:
+ return self.concrete_formulae[sizes][inv]
+
+ # We don't have a concrete formula. Try to instantiate.
+ if sizes not in self.symbolic_formulae:
+ return None # Too bad...
+
+ possible = []
+ for f in self.symbolic_formulae[sizes]:
+ repls = f.find_instantiations(func)
+ for repl in repls:
+ func2 = f.func.xreplace(repl)
+ if not func2._is_suitable_origin():
+ continue
+ diff = func2.difficulty(func)
+ if diff == -1:
+ continue
+ possible.append((diff, repl, f, func2))
+
+ # find the nearest origin
+ possible.sort(key=lambda x: x[0])
+ for _, repl, f, func2 in possible:
+ f2 = Formula(func2, f.z, None, [], f.B.subs(repl),
+ f.C.subs(repl), f.M.subs(repl))
+ if not any(e.has(S.NaN, oo, -oo, zoo) for e in [f2.B, f2.M, f2.C]):
+ return f2
+
+ return None
+
+
+class MeijerFormula:
+ """
+ This class represents a Meijer G-function formula.
+
+ Its data members are:
+ - z, the argument
+ - symbols, the free symbols (parameters) in the formula
+ - func, the function
+ - B, C, M (c/f ordinary Formula)
+ """
+
+ def __init__(self, an, ap, bm, bq, z, symbols, B, C, M, matcher):
+ an, ap, bm, bq = [Tuple(*list(map(expand, w))) for w in [an, ap, bm, bq]]
+ self.func = G_Function(an, ap, bm, bq)
+ self.z = z
+ self.symbols = symbols
+ self._matcher = matcher
+ self.B = B
+ self.C = C
+ self.M = M
+
+ @property
+ def closed_form(self):
+ return reduce(lambda s,m: s+m[0]*m[1], zip(self.C, self.B), S.Zero)
+
+ def try_instantiate(self, func):
+ """
+ Try to instantiate the current formula to (almost) match func.
+ This uses the _matcher passed on init.
+ """
+ if func.signature != self.func.signature:
+ return None
+ res = self._matcher(func)
+ if res is not None:
+ subs, newfunc = res
+ return MeijerFormula(newfunc.an, newfunc.ap, newfunc.bm, newfunc.bq,
+ self.z, [],
+ self.B.subs(subs), self.C.subs(subs),
+ self.M.subs(subs), None)
+
+
+class MeijerFormulaCollection:
+ """
+ This class holds a collection of meijer g formulae.
+ """
+
+ def __init__(self):
+ formulae = []
+ add_meijerg_formulae(formulae)
+ self.formulae = defaultdict(list)
+ for formula in formulae:
+ self.formulae[formula.func.signature].append(formula)
+ self.formulae = dict(self.formulae)
+
+ def lookup_origin(self, func):
+ """ Try to find a formula that matches func. """
+ if func.signature not in self.formulae:
+ return None
+ for formula in self.formulae[func.signature]:
+ res = formula.try_instantiate(func)
+ if res is not None:
+ return res
+
+
+class Operator:
+ """
+ Base class for operators to be applied to our functions.
+
+ Explanation
+ ===========
+
+ These operators are differential operators. They are by convention
+ expressed in the variable D = z*d/dz (although this base class does
+ not actually care).
+ Note that when the operator is applied to an object, we typically do
+ *not* blindly differentiate but instead use a different representation
+ of the z*d/dz operator (see make_derivative_operator).
+
+ To subclass from this, define a __init__ method that initializes a
+ self._poly variable. This variable stores a polynomial. By convention
+ the generator is z*d/dz, and acts to the right of all coefficients.
+
+ Thus this poly
+ x**2 + 2*z*x + 1
+ represents the differential operator
+ (z*d/dz)**2 + 2*z**2*d/dz.
+
+ This class is used only in the implementation of the hypergeometric
+ function expansion algorithm.
+ """
+
+ def apply(self, obj, op):
+ """
+ Apply ``self`` to the object ``obj``, where the generator is ``op``.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.hyperexpand import Operator
+ >>> from sympy.polys.polytools import Poly
+ >>> from sympy.abc import x, y, z
+ >>> op = Operator()
+ >>> op._poly = Poly(x**2 + z*x + y, x)
+ >>> op.apply(z**7, lambda f: f.diff(z))
+ y*z**7 + 7*z**7 + 42*z**5
+ """
+ coeffs = self._poly.all_coeffs()
+ coeffs.reverse()
+ diffs = [obj]
+ for c in coeffs[1:]:
+ diffs.append(op(diffs[-1]))
+ r = coeffs[0]*diffs[0]
+ for c, d in zip(coeffs[1:], diffs[1:]):
+ r += c*d
+ return r
+
+
+class MultOperator(Operator):
+ """ Simply multiply by a "constant" """
+
+ def __init__(self, p):
+ self._poly = Poly(p, _x)
+
+
+class ShiftA(Operator):
+ """ Increment an upper index. """
+
+ def __init__(self, ai):
+ ai = sympify(ai)
+ if ai == 0:
+ raise ValueError('Cannot increment zero upper index.')
+ self._poly = Poly(_x/ai + 1, _x)
+
+ def __str__(self):
+ return '' % (1/self._poly.all_coeffs()[0])
+
+
+class ShiftB(Operator):
+ """ Decrement a lower index. """
+
+ def __init__(self, bi):
+ bi = sympify(bi)
+ if bi == 1:
+ raise ValueError('Cannot decrement unit lower index.')
+ self._poly = Poly(_x/(bi - 1) + 1, _x)
+
+ def __str__(self):
+ return '' % (1/self._poly.all_coeffs()[0] + 1)
+
+
+class UnShiftA(Operator):
+ """ Decrement an upper index. """
+
+ def __init__(self, ap, bq, i, z):
+ """ Note: i counts from zero! """
+ ap, bq, i = list(map(sympify, [ap, bq, i]))
+
+ self._ap = ap
+ self._bq = bq
+ self._i = i
+
+ ap = list(ap)
+ bq = list(bq)
+ ai = ap.pop(i) - 1
+
+ if ai == 0:
+ raise ValueError('Cannot decrement unit upper index.')
+
+ m = Poly(z*ai, _x)
+ for a in ap:
+ m *= Poly(_x + a, _x)
+
+ A = Dummy('A')
+ n = D = Poly(ai*A - ai, A)
+ for b in bq:
+ n *= D + (b - 1).as_poly(A)
+
+ b0 = -n.nth(0)
+ if b0 == 0:
+ raise ValueError('Cannot decrement upper index: '
+ 'cancels with lower')
+
+ n = Poly(Poly(n.all_coeffs()[:-1], A).as_expr().subs(A, _x/ai + 1), _x)
+
+ self._poly = Poly((n - m)/b0, _x)
+
+ def __str__(self):
+ return '' % (self._i,
+ self._ap, self._bq)
+
+
+class UnShiftB(Operator):
+ """ Increment a lower index. """
+
+ def __init__(self, ap, bq, i, z):
+ """ Note: i counts from zero! """
+ ap, bq, i = list(map(sympify, [ap, bq, i]))
+
+ self._ap = ap
+ self._bq = bq
+ self._i = i
+
+ ap = list(ap)
+ bq = list(bq)
+ bi = bq.pop(i) + 1
+
+ if bi == 0:
+ raise ValueError('Cannot increment -1 lower index.')
+
+ m = Poly(_x*(bi - 1), _x)
+ for b in bq:
+ m *= Poly(_x + b - 1, _x)
+
+ B = Dummy('B')
+ D = Poly((bi - 1)*B - bi + 1, B)
+ n = Poly(z, B)
+ for a in ap:
+ n *= (D + a.as_poly(B))
+
+ b0 = n.nth(0)
+ if b0 == 0:
+ raise ValueError('Cannot increment index: cancels with upper')
+
+ n = Poly(Poly(n.all_coeffs()[:-1], B).as_expr().subs(
+ B, _x/(bi - 1) + 1), _x)
+
+ self._poly = Poly((m - n)/b0, _x)
+
+ def __str__(self):
+ return '' % (self._i,
+ self._ap, self._bq)
+
+
+class MeijerShiftA(Operator):
+ """ Increment an upper b index. """
+
+ def __init__(self, bi):
+ bi = sympify(bi)
+ self._poly = Poly(bi - _x, _x)
+
+ def __str__(self):
+ return '' % (self._poly.all_coeffs()[1])
+
+
+class MeijerShiftB(Operator):
+ """ Decrement an upper a index. """
+
+ def __init__(self, bi):
+ bi = sympify(bi)
+ self._poly = Poly(1 - bi + _x, _x)
+
+ def __str__(self):
+ return '' % (1 - self._poly.all_coeffs()[1])
+
+
+class MeijerShiftC(Operator):
+ """ Increment a lower b index. """
+
+ def __init__(self, bi):
+ bi = sympify(bi)
+ self._poly = Poly(-bi + _x, _x)
+
+ def __str__(self):
+ return '' % (-self._poly.all_coeffs()[1])
+
+
+class MeijerShiftD(Operator):
+ """ Decrement a lower a index. """
+
+ def __init__(self, bi):
+ bi = sympify(bi)
+ self._poly = Poly(bi - 1 - _x, _x)
+
+ def __str__(self):
+ return '' % (self._poly.all_coeffs()[1] + 1)
+
+
+class MeijerUnShiftA(Operator):
+ """ Decrement an upper b index. """
+
+ def __init__(self, an, ap, bm, bq, i, z):
+ """ Note: i counts from zero! """
+ an, ap, bm, bq, i = list(map(sympify, [an, ap, bm, bq, i]))
+
+ self._an = an
+ self._ap = ap
+ self._bm = bm
+ self._bq = bq
+ self._i = i
+
+ an = list(an)
+ ap = list(ap)
+ bm = list(bm)
+ bq = list(bq)
+ bi = bm.pop(i) - 1
+
+ m = Poly(1, _x) * prod(Poly(b - _x, _x) for b in bm) * prod(Poly(_x - b, _x) for b in bq)
+
+ A = Dummy('A')
+ D = Poly(bi - A, A)
+ n = Poly(z, A) * prod((D + 1 - a) for a in an) * prod((-D + a - 1) for a in ap)
+
+ b0 = n.nth(0)
+ if b0 == 0:
+ raise ValueError('Cannot decrement upper b index (cancels)')
+
+ n = Poly(Poly(n.all_coeffs()[:-1], A).as_expr().subs(A, bi - _x), _x)
+
+ self._poly = Poly((m - n)/b0, _x)
+
+ def __str__(self):
+ return '' % (self._i,
+ self._an, self._ap, self._bm, self._bq)
+
+
+class MeijerUnShiftB(Operator):
+ """ Increment an upper a index. """
+
+ def __init__(self, an, ap, bm, bq, i, z):
+ """ Note: i counts from zero! """
+ an, ap, bm, bq, i = list(map(sympify, [an, ap, bm, bq, i]))
+
+ self._an = an
+ self._ap = ap
+ self._bm = bm
+ self._bq = bq
+ self._i = i
+
+ an = list(an)
+ ap = list(ap)
+ bm = list(bm)
+ bq = list(bq)
+ ai = an.pop(i) + 1
+
+ m = Poly(z, _x)
+ for a in an:
+ m *= Poly(1 - a + _x, _x)
+ for a in ap:
+ m *= Poly(a - 1 - _x, _x)
+
+ B = Dummy('B')
+ D = Poly(B + ai - 1, B)
+ n = Poly(1, B)
+ for b in bm:
+ n *= (-D + b)
+ for b in bq:
+ n *= (D - b)
+
+ b0 = n.nth(0)
+ if b0 == 0:
+ raise ValueError('Cannot increment upper a index (cancels)')
+
+ n = Poly(Poly(n.all_coeffs()[:-1], B).as_expr().subs(
+ B, 1 - ai + _x), _x)
+
+ self._poly = Poly((m - n)/b0, _x)
+
+ def __str__(self):
+ return '' % (self._i,
+ self._an, self._ap, self._bm, self._bq)
+
+
+class MeijerUnShiftC(Operator):
+ """ Decrement a lower b index. """
+ # XXX this is "essentially" the same as MeijerUnShiftA. This "essentially"
+ # can be made rigorous using the functional equation G(1/z) = G'(z),
+ # where G' denotes a G function of slightly altered parameters.
+ # However, sorting out the details seems harder than just coding it
+ # again.
+
+ def __init__(self, an, ap, bm, bq, i, z):
+ """ Note: i counts from zero! """
+ an, ap, bm, bq, i = list(map(sympify, [an, ap, bm, bq, i]))
+
+ self._an = an
+ self._ap = ap
+ self._bm = bm
+ self._bq = bq
+ self._i = i
+
+ an = list(an)
+ ap = list(ap)
+ bm = list(bm)
+ bq = list(bq)
+ bi = bq.pop(i) - 1
+
+ m = Poly(1, _x)
+ for b in bm:
+ m *= Poly(b - _x, _x)
+ for b in bq:
+ m *= Poly(_x - b, _x)
+
+ C = Dummy('C')
+ D = Poly(bi + C, C)
+ n = Poly(z, C)
+ for a in an:
+ n *= (D + 1 - a)
+ for a in ap:
+ n *= (-D + a - 1)
+
+ b0 = n.nth(0)
+ if b0 == 0:
+ raise ValueError('Cannot decrement lower b index (cancels)')
+
+ n = Poly(Poly(n.all_coeffs()[:-1], C).as_expr().subs(C, _x - bi), _x)
+
+ self._poly = Poly((m - n)/b0, _x)
+
+ def __str__(self):
+ return '' % (self._i,
+ self._an, self._ap, self._bm, self._bq)
+
+
+class MeijerUnShiftD(Operator):
+ """ Increment a lower a index. """
+ # XXX This is essentially the same as MeijerUnShiftA.
+ # See comment at MeijerUnShiftC.
+
+ def __init__(self, an, ap, bm, bq, i, z):
+ """ Note: i counts from zero! """
+ an, ap, bm, bq, i = list(map(sympify, [an, ap, bm, bq, i]))
+
+ self._an = an
+ self._ap = ap
+ self._bm = bm
+ self._bq = bq
+ self._i = i
+
+ an = list(an)
+ ap = list(ap)
+ bm = list(bm)
+ bq = list(bq)
+ ai = ap.pop(i) + 1
+
+ m = Poly(z, _x)
+ for a in an:
+ m *= Poly(1 - a + _x, _x)
+ for a in ap:
+ m *= Poly(a - 1 - _x, _x)
+
+ B = Dummy('B') # - this is the shift operator `D_I`
+ D = Poly(ai - 1 - B, B)
+ n = Poly(1, B)
+ for b in bm:
+ n *= (-D + b)
+ for b in bq:
+ n *= (D - b)
+
+ b0 = n.nth(0)
+ if b0 == 0:
+ raise ValueError('Cannot increment lower a index (cancels)')
+
+ n = Poly(Poly(n.all_coeffs()[:-1], B).as_expr().subs(
+ B, ai - 1 - _x), _x)
+
+ self._poly = Poly((m - n)/b0, _x)
+
+ def __str__(self):
+ return '' % (self._i,
+ self._an, self._ap, self._bm, self._bq)
+
+
+class ReduceOrder(Operator):
+ """ Reduce Order by cancelling an upper and a lower index. """
+
+ def __new__(cls, ai, bj):
+ """ For convenience if reduction is not possible, return None. """
+ ai = sympify(ai)
+ bj = sympify(bj)
+ n = ai - bj
+ if not n.is_Integer or n < 0:
+ return None
+ if bj.is_integer and bj.is_nonpositive:
+ return None
+
+ expr = Operator.__new__(cls)
+
+ p = S.One
+ for k in range(n):
+ p *= (_x + bj + k)/(bj + k)
+
+ expr._poly = Poly(p, _x)
+ expr._a = ai
+ expr._b = bj
+
+ return expr
+
+ @classmethod
+ def _meijer(cls, b, a, sign):
+ """ Cancel b + sign*s and a + sign*s
+ This is for meijer G functions. """
+ b = sympify(b)
+ a = sympify(a)
+ n = b - a
+ if n.is_negative or not n.is_Integer:
+ return None
+
+ expr = Operator.__new__(cls)
+
+ p = S.One
+ for k in range(n):
+ p *= (sign*_x + a + k)
+
+ expr._poly = Poly(p, _x)
+ if sign == -1:
+ expr._a = b
+ expr._b = a
+ else:
+ expr._b = Add(1, a - 1, evaluate=False)
+ expr._a = Add(1, b - 1, evaluate=False)
+
+ return expr
+
+ @classmethod
+ def meijer_minus(cls, b, a):
+ return cls._meijer(b, a, -1)
+
+ @classmethod
+ def meijer_plus(cls, a, b):
+ return cls._meijer(1 - a, 1 - b, 1)
+
+ def __str__(self):
+ return '' % \
+ (self._a, self._b)
+
+
+def _reduce_order(ap, bq, gen, key):
+ """ Order reduction algorithm used in Hypergeometric and Meijer G """
+ ap = list(ap)
+ bq = list(bq)
+
+ ap.sort(key=key)
+ bq.sort(key=key)
+
+ nap = []
+ # we will edit bq in place
+ operators = []
+ for a in ap:
+ op = None
+ for i in range(len(bq)):
+ op = gen(a, bq[i])
+ if op is not None:
+ bq.pop(i)
+ break
+ if op is None:
+ nap.append(a)
+ else:
+ operators.append(op)
+
+ return nap, bq, operators
+
+
+def reduce_order(func):
+ """
+ Given the hypergeometric function ``func``, find a sequence of operators to
+ reduces order as much as possible.
+
+ Explanation
+ ===========
+
+ Return (newfunc, [operators]), where applying the operators to the
+ hypergeometric function newfunc yields func.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.hyperexpand import reduce_order, Hyper_Function
+ >>> reduce_order(Hyper_Function((1, 2), (3, 4)))
+ (Hyper_Function((1, 2), (3, 4)), [])
+ >>> reduce_order(Hyper_Function((1,), (1,)))
+ (Hyper_Function((), ()), [])
+ >>> reduce_order(Hyper_Function((2, 4), (3, 3)))
+ (Hyper_Function((2,), (3,)), [])
+ """
+ nap, nbq, operators = _reduce_order(func.ap, func.bq, ReduceOrder, default_sort_key)
+
+ return Hyper_Function(Tuple(*nap), Tuple(*nbq)), operators
+
+
+def reduce_order_meijer(func):
+ """
+ Given the Meijer G function parameters, ``func``, find a sequence of
+ operators that reduces order as much as possible.
+
+ Return newfunc, [operators].
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.hyperexpand import (reduce_order_meijer,
+ ... G_Function)
+ >>> reduce_order_meijer(G_Function([3, 4], [5, 6], [3, 4], [1, 2]))[0]
+ G_Function((4, 3), (5, 6), (3, 4), (2, 1))
+ >>> reduce_order_meijer(G_Function([3, 4], [5, 6], [3, 4], [1, 8]))[0]
+ G_Function((3,), (5, 6), (3, 4), (1,))
+ >>> reduce_order_meijer(G_Function([3, 4], [5, 6], [7, 5], [1, 5]))[0]
+ G_Function((3,), (), (), (1,))
+ >>> reduce_order_meijer(G_Function([3, 4], [5, 6], [7, 5], [5, 3]))[0]
+ G_Function((), (), (), ())
+ """
+
+ nan, nbq, ops1 = _reduce_order(func.an, func.bq, ReduceOrder.meijer_plus,
+ lambda x: default_sort_key(-x))
+ nbm, nap, ops2 = _reduce_order(func.bm, func.ap, ReduceOrder.meijer_minus,
+ default_sort_key)
+
+ return G_Function(nan, nap, nbm, nbq), ops1 + ops2
+
+
+def make_derivative_operator(M, z):
+ """ Create a derivative operator, to be passed to Operator.apply. """
+ def doit(C):
+ r = z*C.diff(z) + C*M
+ r = r.applyfunc(make_simp(z))
+ return r
+ return doit
+
+
+def apply_operators(obj, ops, op):
+ """
+ Apply the list of operators ``ops`` to object ``obj``, substituting
+ ``op`` for the generator.
+ """
+ res = obj
+ for o in reversed(ops):
+ res = o.apply(res, op)
+ return res
+
+
+def devise_plan(target, origin, z):
+ """
+ Devise a plan (consisting of shift and un-shift operators) to be applied
+ to the hypergeometric function ``target`` to yield ``origin``.
+ Returns a list of operators.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.hyperexpand import devise_plan, Hyper_Function
+ >>> from sympy.abc import z
+
+ Nothing to do:
+
+ >>> devise_plan(Hyper_Function((1, 2), ()), Hyper_Function((1, 2), ()), z)
+ []
+ >>> devise_plan(Hyper_Function((), (1, 2)), Hyper_Function((), (1, 2)), z)
+ []
+
+ Very simple plans:
+
+ >>> devise_plan(Hyper_Function((2,), ()), Hyper_Function((1,), ()), z)
+ []
+ >>> devise_plan(Hyper_Function((), (2,)), Hyper_Function((), (1,)), z)
+ []
+
+ Several buckets:
+
+ >>> from sympy import S
+ >>> devise_plan(Hyper_Function((1, S.Half), ()),
+ ... Hyper_Function((2, S('3/2')), ()), z) #doctest: +NORMALIZE_WHITESPACE
+ [,
+ ]
+
+ A slightly more complicated plan:
+
+ >>> devise_plan(Hyper_Function((1, 3), ()), Hyper_Function((2, 2), ()), z)
+ [, ]
+
+ Another more complicated plan: (note that the ap have to be shifted first!)
+
+ >>> devise_plan(Hyper_Function((1, -1), (2,)), Hyper_Function((3, -2), (4,)), z)
+ [, ,
+ ,
+ , ]
+ """
+ abuckets, bbuckets, nabuckets, nbbuckets = [sift(params, _mod1) for
+ params in (target.ap, target.bq, origin.ap, origin.bq)]
+
+ if len(list(abuckets.keys())) != len(list(nabuckets.keys())) or \
+ len(list(bbuckets.keys())) != len(list(nbbuckets.keys())):
+ raise ValueError('%s not reachable from %s' % (target, origin))
+
+ ops = []
+
+ def do_shifts(fro, to, inc, dec):
+ ops = []
+ for i in range(len(fro)):
+ if to[i] - fro[i] > 0:
+ sh = inc
+ ch = 1
+ else:
+ sh = dec
+ ch = -1
+
+ while to[i] != fro[i]:
+ ops += [sh(fro, i)]
+ fro[i] += ch
+
+ return ops
+
+ def do_shifts_a(nal, nbk, al, aother, bother):
+ """ Shift us from (nal, nbk) to (al, nbk). """
+ return do_shifts(nal, al, lambda p, i: ShiftA(p[i]),
+ lambda p, i: UnShiftA(p + aother, nbk + bother, i, z))
+
+ def do_shifts_b(nal, nbk, bk, aother, bother):
+ """ Shift us from (nal, nbk) to (nal, bk). """
+ return do_shifts(nbk, bk,
+ lambda p, i: UnShiftB(nal + aother, p + bother, i, z),
+ lambda p, i: ShiftB(p[i]))
+
+ for r in sorted(list(abuckets.keys()) + list(bbuckets.keys()), key=default_sort_key):
+ al = ()
+ nal = ()
+ bk = ()
+ nbk = ()
+ if r in abuckets:
+ al = abuckets[r]
+ nal = nabuckets[r]
+ if r in bbuckets:
+ bk = bbuckets[r]
+ nbk = nbbuckets[r]
+ if len(al) != len(nal) or len(bk) != len(nbk):
+ raise ValueError('%s not reachable from %s' % (target, origin))
+
+ al, nal, bk, nbk = [sorted(w, key=default_sort_key)
+ for w in [al, nal, bk, nbk]]
+
+ def others(dic, key):
+ l = []
+ for k in dic:
+ if k != key:
+ l.extend(dic[k])
+ return l
+ aother = others(nabuckets, r)
+ bother = others(nbbuckets, r)
+
+ if len(al) == 0:
+ # there can be no complications, just shift the bs as we please
+ ops += do_shifts_b([], nbk, bk, aother, bother)
+ elif len(bk) == 0:
+ # there can be no complications, just shift the as as we please
+ ops += do_shifts_a(nal, [], al, aother, bother)
+ else:
+ namax = nal[-1]
+ amax = al[-1]
+
+ if nbk[0] - namax <= 0 or bk[0] - amax <= 0:
+ raise ValueError('Non-suitable parameters.')
+
+ if namax - amax > 0:
+ # we are going to shift down - first do the as, then the bs
+ ops += do_shifts_a(nal, nbk, al, aother, bother)
+ ops += do_shifts_b(al, nbk, bk, aother, bother)
+ else:
+ # we are going to shift up - first do the bs, then the as
+ ops += do_shifts_b(nal, nbk, bk, aother, bother)
+ ops += do_shifts_a(nal, bk, al, aother, bother)
+
+ nabuckets[r] = al
+ nbbuckets[r] = bk
+
+ ops.reverse()
+ return ops
+
+
+def try_shifted_sum(func, z):
+ """ Try to recognise a hypergeometric sum that starts from k > 0. """
+ abuckets, bbuckets = sift(func.ap, _mod1), sift(func.bq, _mod1)
+ if len(abuckets[S.Zero]) != 1:
+ return None
+ r = abuckets[S.Zero][0]
+ if r <= 0:
+ return None
+ if S.Zero not in bbuckets:
+ return None
+ l = list(bbuckets[S.Zero])
+ l.sort()
+ k = l[0]
+ if k <= 0:
+ return None
+
+ nap = list(func.ap)
+ nap.remove(r)
+ nbq = list(func.bq)
+ nbq.remove(k)
+ k -= 1
+ nap = [x - k for x in nap]
+ nbq = [x - k for x in nbq]
+
+ ops = []
+ for n in range(r - 1):
+ ops.append(ShiftA(n + 1))
+ ops.reverse()
+
+ fac = factorial(k)/z**k
+ fac *= Mul(*[rf(b, k) for b in nbq])
+ fac /= Mul(*[rf(a, k) for a in nap])
+
+ ops += [MultOperator(fac)]
+
+ p = 0
+ for n in range(k):
+ m = z**n/factorial(n)
+ m *= Mul(*[rf(a, n) for a in nap])
+ m /= Mul(*[rf(b, n) for b in nbq])
+ p += m
+
+ return Hyper_Function(nap, nbq), ops, -p
+
+
+def try_polynomial(func, z):
+ """ Recognise polynomial cases. Returns None if not such a case.
+ Requires order to be fully reduced. """
+ abuckets, bbuckets = sift(func.ap, _mod1), sift(func.bq, _mod1)
+ a0 = abuckets[S.Zero]
+ b0 = bbuckets[S.Zero]
+ a0.sort()
+ b0.sort()
+ al0 = [x for x in a0 if x <= 0]
+ bl0 = [x for x in b0 if x <= 0]
+
+ if bl0 and all(a < bl0[-1] for a in al0):
+ return oo
+ if not al0:
+ return None
+
+ a = al0[-1]
+ fac = 1
+ res = S.One
+ for n in Tuple(*list(range(-a))):
+ fac *= z
+ fac /= n + 1
+ fac *= Mul(*[a + n for a in func.ap])
+ fac /= Mul(*[b + n for b in func.bq])
+ res += fac
+ return res
+
+
+def try_lerchphi(func):
+ """
+ Try to find an expression for Hyper_Function ``func`` in terms of Lerch
+ Transcendents.
+
+ Return None if no such expression can be found.
+ """
+ # This is actually quite simple, and is described in Roach's paper,
+ # section 18.
+ # We don't need to implement the reduction to polylog here, this
+ # is handled by expand_func.
+
+ # First we need to figure out if the summation coefficient is a rational
+ # function of the summation index, and construct that rational function.
+ abuckets, bbuckets = sift(func.ap, _mod1), sift(func.bq, _mod1)
+
+ paired = {}
+ for key, value in abuckets.items():
+ if key != 0 and key not in bbuckets:
+ return None
+ bvalue = bbuckets[key]
+ paired[key] = (list(value), list(bvalue))
+ bbuckets.pop(key, None)
+ if bbuckets != {}:
+ return None
+ if S.Zero not in abuckets:
+ return None
+ aints, bints = paired[S.Zero]
+ # Account for the additional n! in denominator
+ paired[S.Zero] = (aints, bints + [1])
+
+ t = Dummy('t')
+ numer = S.One
+ denom = S.One
+ for key, (avalue, bvalue) in paired.items():
+ if len(avalue) != len(bvalue):
+ return None
+ # Note that since order has been reduced fully, all the b are
+ # bigger than all the a they differ from by an integer. In particular
+ # if there are any negative b left, this function is not well-defined.
+ for a, b in zip(avalue, bvalue):
+ if (a - b).is_positive:
+ k = a - b
+ numer *= rf(b + t, k)
+ denom *= rf(b, k)
+ else:
+ k = b - a
+ numer *= rf(a, k)
+ denom *= rf(a + t, k)
+
+ # Now do a partial fraction decomposition.
+ # We assemble two structures: a list monomials of pairs (a, b) representing
+ # a*t**b (b a non-negative integer), and a dict terms, where
+ # terms[a] = [(b, c)] means that there is a term b/(t-a)**c.
+ part = apart(numer/denom, t)
+ args = Add.make_args(part)
+ monomials = []
+ terms = {}
+ for arg in args:
+ numer, denom = arg.as_numer_denom()
+ if not denom.has(t):
+ p = Poly(numer, t)
+ if not p.is_monomial:
+ raise TypeError("p should be monomial")
+ ((b, ), a) = p.LT()
+ monomials += [(a/denom, b)]
+ continue
+ if numer.has(t):
+ raise NotImplementedError('Need partial fraction decomposition'
+ ' with linear denominators')
+ indep, [dep] = denom.as_coeff_mul(t)
+ n = 1
+ if dep.is_Pow:
+ n = dep.exp
+ dep = dep.base
+ if dep == t:
+ a == 0
+ elif dep.is_Add:
+ a, tmp = dep.as_independent(t)
+ b = 1
+ if tmp != t:
+ b, _ = tmp.as_independent(t)
+ if dep != b*t + a:
+ raise NotImplementedError('unrecognised form %s' % dep)
+ a /= b
+ indep *= b**n
+ else:
+ raise NotImplementedError('unrecognised form of partial fraction')
+ terms.setdefault(a, []).append((numer/indep, n))
+
+ # Now that we have this information, assemble our formula. All the
+ # monomials yield rational functions and go into one basis element.
+ # The terms[a] are related by differentiation. If the largest exponent is
+ # n, we need lerchphi(z, k, a) for k = 1, 2, ..., n.
+ # deriv maps a basis to its derivative, expressed as a C(z)-linear
+ # combination of other basis elements.
+ deriv = {}
+ coeffs = {}
+ z = Dummy('z')
+ monomials.sort(key=lambda x: x[1])
+ mon = {0: 1/(1 - z)}
+ if monomials:
+ for k in range(monomials[-1][1]):
+ mon[k + 1] = z*mon[k].diff(z)
+ for a, n in monomials:
+ coeffs.setdefault(S.One, []).append(a*mon[n])
+ for a, l in terms.items():
+ for c, k in l:
+ coeffs.setdefault(lerchphi(z, k, a), []).append(c)
+ l.sort(key=lambda x: x[1])
+ for k in range(2, l[-1][1] + 1):
+ deriv[lerchphi(z, k, a)] = [(-a, lerchphi(z, k, a)),
+ (1, lerchphi(z, k - 1, a))]
+ deriv[lerchphi(z, 1, a)] = [(-a, lerchphi(z, 1, a)),
+ (1/(1 - z), S.One)]
+ trans = {}
+ for n, b in enumerate([S.One] + list(deriv.keys())):
+ trans[b] = n
+ basis = [expand_func(b) for (b, _) in sorted(trans.items(),
+ key=lambda x:x[1])]
+ B = Matrix(basis)
+ C = Matrix([[0]*len(B)])
+ for b, c in coeffs.items():
+ C[trans[b]] = Add(*c)
+ M = zeros(len(B))
+ for b, l in deriv.items():
+ for c, b2 in l:
+ M[trans[b], trans[b2]] = c
+ return Formula(func, z, None, [], B, C, M)
+
+
+def build_hypergeometric_formula(func):
+ """
+ Create a formula object representing the hypergeometric function ``func``.
+
+ """
+ # We know that no `ap` are negative integers, otherwise "detect poly"
+ # would have kicked in. However, `ap` could be empty. In this case we can
+ # use a different basis.
+ # I'm not aware of a basis that works in all cases.
+ z = Dummy('z')
+ if func.ap:
+ afactors = [_x + a for a in func.ap]
+ bfactors = [_x + b - 1 for b in func.bq]
+ expr = _x*Mul(*bfactors) - z*Mul(*afactors)
+ poly = Poly(expr, _x)
+ n = poly.degree()
+ basis = []
+ M = zeros(n)
+ for k in range(n):
+ a = func.ap[0] + k
+ basis += [hyper([a] + list(func.ap[1:]), func.bq, z)]
+ if k < n - 1:
+ M[k, k] = -a
+ M[k, k + 1] = a
+ B = Matrix(basis)
+ C = Matrix([[1] + [0]*(n - 1)])
+ derivs = [eye(n)]
+ for k in range(n):
+ derivs.append(M*derivs[k])
+ l = poly.all_coeffs()
+ l.reverse()
+ res = [0]*n
+ for k, c in enumerate(l):
+ for r, d in enumerate(C*derivs[k]):
+ res[r] += c*d
+ for k, c in enumerate(res):
+ M[n - 1, k] = -c/derivs[n - 1][0, n - 1]/poly.all_coeffs()[0]
+ return Formula(func, z, None, [], B, C, M)
+ else:
+ # Since there are no `ap`, none of the `bq` can be non-positive
+ # integers.
+ basis = []
+ bq = list(func.bq[:])
+ for i in range(len(bq)):
+ basis += [hyper([], bq, z)]
+ bq[i] += 1
+ basis += [hyper([], bq, z)]
+ B = Matrix(basis)
+ n = len(B)
+ C = Matrix([[1] + [0]*(n - 1)])
+ M = zeros(n)
+ M[0, n - 1] = z/Mul(*func.bq)
+ for k in range(1, n):
+ M[k, k - 1] = func.bq[k - 1]
+ M[k, k] = -func.bq[k - 1]
+ return Formula(func, z, None, [], B, C, M)
+
+
+def hyperexpand_special(ap, bq, z):
+ """
+ Try to find a closed-form expression for hyper(ap, bq, z), where ``z``
+ is supposed to be a "special" value, e.g. 1.
+
+ This function tries various of the classical summation formulae
+ (Gauss, Saalschuetz, etc).
+ """
+ # This code is very ad-hoc. There are many clever algorithms
+ # (notably Zeilberger's) related to this problem.
+ # For now we just want a few simple cases to work.
+ p, q = len(ap), len(bq)
+ z_ = z
+ z = unpolarify(z)
+ if z == 0:
+ return S.One
+ from sympy.simplify.simplify import simplify
+ if p == 2 and q == 1:
+ # 2F1
+ a, b, c = ap + bq
+ if z == 1:
+ # Gauss
+ return gamma(c - a - b)*gamma(c)/gamma(c - a)/gamma(c - b)
+ if z == -1 and simplify(b - a + c) == 1:
+ b, a = a, b
+ if z == -1 and simplify(a - b + c) == 1:
+ # Kummer
+ if b.is_integer and b.is_negative:
+ return 2*cos(pi*b/2)*gamma(-b)*gamma(b - a + 1) \
+ /gamma(-b/2)/gamma(b/2 - a + 1)
+ else:
+ return gamma(b/2 + 1)*gamma(b - a + 1) \
+ /gamma(b + 1)/gamma(b/2 - a + 1)
+ # TODO tons of more formulae
+ # investigate what algorithms exist
+ return hyper(ap, bq, z_)
+
+_collection = None
+
+
+def _hyperexpand(func, z, ops0=[], z0=Dummy('z0'), premult=1, prem=0,
+ rewrite='default'):
+ """
+ Try to find an expression for the hypergeometric function ``func``.
+
+ Explanation
+ ===========
+
+ The result is expressed in terms of a dummy variable ``z0``. Then it
+ is multiplied by ``premult``. Then ``ops0`` is applied.
+ ``premult`` must be a*z**prem for some a independent of ``z``.
+ """
+
+ if z.is_zero:
+ return S.One
+
+ from sympy.simplify.simplify import simplify
+
+ z = polarify(z, subs=False)
+ if rewrite == 'default':
+ rewrite = 'nonrepsmall'
+
+ def carryout_plan(f, ops):
+ C = apply_operators(f.C.subs(f.z, z0), ops,
+ make_derivative_operator(f.M.subs(f.z, z0), z0))
+ C = apply_operators(C, ops0,
+ make_derivative_operator(f.M.subs(f.z, z0)
+ + prem*eye(f.M.shape[0]), z0))
+
+ if premult == 1:
+ C = C.applyfunc(make_simp(z0))
+ r = reduce(lambda s,m: s+m[0]*m[1], zip(C, f.B.subs(f.z, z0)), S.Zero)*premult
+ res = r.subs(z0, z)
+ if rewrite:
+ res = res.rewrite(rewrite)
+ return res
+
+ # TODO
+ # The following would be possible:
+ # *) PFD Duplication (see Kelly Roach's paper)
+ # *) In a similar spirit, try_lerchphi() can be generalised considerably.
+
+ global _collection
+ if _collection is None:
+ _collection = FormulaCollection()
+
+ debug('Trying to expand hypergeometric function ', func)
+
+ # First reduce order as much as possible.
+ func, ops = reduce_order(func)
+ if ops:
+ debug(' Reduced order to ', func)
+ else:
+ debug(' Could not reduce order.')
+
+ # Now try polynomial cases
+ res = try_polynomial(func, z0)
+ if res is not None:
+ debug(' Recognised polynomial.')
+ p = apply_operators(res, ops, lambda f: z0*f.diff(z0))
+ p = apply_operators(p*premult, ops0, lambda f: z0*f.diff(z0))
+ return unpolarify(simplify(p).subs(z0, z))
+
+ # Try to recognise a shifted sum.
+ p = S.Zero
+ res = try_shifted_sum(func, z0)
+ if res is not None:
+ func, nops, p = res
+ debug(' Recognised shifted sum, reduced order to ', func)
+ ops += nops
+
+ # apply the plan for poly
+ p = apply_operators(p, ops, lambda f: z0*f.diff(z0))
+ p = apply_operators(p*premult, ops0, lambda f: z0*f.diff(z0))
+ p = simplify(p).subs(z0, z)
+
+ # Try special expansions early.
+ if unpolarify(z) in [1, -1] and (len(func.ap), len(func.bq)) == (2, 1):
+ f = build_hypergeometric_formula(func)
+ r = carryout_plan(f, ops).replace(hyper, hyperexpand_special)
+ if not r.has(hyper):
+ return r + p
+
+ # Try to find a formula in our collection
+ formula = _collection.lookup_origin(func)
+
+ # Now try a lerch phi formula
+ if formula is None:
+ formula = try_lerchphi(func)
+
+ if formula is None:
+ debug(' Could not find an origin. ',
+ 'Will return answer in terms of '
+ 'simpler hypergeometric functions.')
+ formula = build_hypergeometric_formula(func)
+
+ debug(' Found an origin: ', formula.closed_form, ' ', formula.func)
+
+ # We need to find the operators that convert formula into func.
+ ops += devise_plan(func, formula.func, z0)
+
+ # Now carry out the plan.
+ r = carryout_plan(formula, ops) + p
+
+ return powdenest(r, polar=True).replace(hyper, hyperexpand_special)
+
+
+def devise_plan_meijer(fro, to, z):
+ """
+ Find operators to convert G-function ``fro`` into G-function ``to``.
+
+ Explanation
+ ===========
+
+ It is assumed that ``fro`` and ``to`` have the same signatures, and that in fact
+ any corresponding pair of parameters differs by integers, and a direct path
+ is possible. I.e. if there are parameters a1 b1 c1 and a2 b2 c2 it is
+ assumed that a1 can be shifted to a2, etc. The only thing this routine
+ determines is the order of shifts to apply, nothing clever will be tried.
+ It is also assumed that ``fro`` is suitable.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.hyperexpand import (devise_plan_meijer,
+ ... G_Function)
+ >>> from sympy.abc import z
+
+ Empty plan:
+
+ >>> devise_plan_meijer(G_Function([1], [2], [3], [4]),
+ ... G_Function([1], [2], [3], [4]), z)
+ []
+
+ Very simple plans:
+
+ >>> devise_plan_meijer(G_Function([0], [], [], []),
+ ... G_Function([1], [], [], []), z)
+ []
+ >>> devise_plan_meijer(G_Function([0], [], [], []),
+ ... G_Function([-1], [], [], []), z)
+ []
+ >>> devise_plan_meijer(G_Function([], [1], [], []),
+ ... G_Function([], [2], [], []), z)
+ []
+
+ Slightly more complicated plans:
+
+ >>> devise_plan_meijer(G_Function([0], [], [], []),
+ ... G_Function([2], [], [], []), z)
+ [,
+ ]
+ >>> devise_plan_meijer(G_Function([0], [], [0], []),
+ ... G_Function([-1], [], [1], []), z)
+ [, ]
+
+ Order matters:
+
+ >>> devise_plan_meijer(G_Function([0], [], [0], []),
+ ... G_Function([1], [], [1], []), z)
+ [, ]
+ """
+ # TODO for now, we use the following simple heuristic: inverse-shift
+ # when possible, shift otherwise. Give up if we cannot make progress.
+
+ def try_shift(f, t, shifter, diff, counter):
+ """ Try to apply ``shifter`` in order to bring some element in ``f``
+ nearer to its counterpart in ``to``. ``diff`` is +/- 1 and
+ determines the effect of ``shifter``. Counter is a list of elements
+ blocking the shift.
+
+ Return an operator if change was possible, else None.
+ """
+ for idx, (a, b) in enumerate(zip(f, t)):
+ if (
+ (a - b).is_integer and (b - a)/diff > 0 and
+ all(a != x for x in counter)):
+ sh = shifter(idx)
+ f[idx] += diff
+ return sh
+ fan = list(fro.an)
+ fap = list(fro.ap)
+ fbm = list(fro.bm)
+ fbq = list(fro.bq)
+ ops = []
+ change = True
+ while change:
+ change = False
+ op = try_shift(fan, to.an,
+ lambda i: MeijerUnShiftB(fan, fap, fbm, fbq, i, z),
+ 1, fbm + fbq)
+ if op is not None:
+ ops += [op]
+ change = True
+ continue
+ op = try_shift(fap, to.ap,
+ lambda i: MeijerUnShiftD(fan, fap, fbm, fbq, i, z),
+ 1, fbm + fbq)
+ if op is not None:
+ ops += [op]
+ change = True
+ continue
+ op = try_shift(fbm, to.bm,
+ lambda i: MeijerUnShiftA(fan, fap, fbm, fbq, i, z),
+ -1, fan + fap)
+ if op is not None:
+ ops += [op]
+ change = True
+ continue
+ op = try_shift(fbq, to.bq,
+ lambda i: MeijerUnShiftC(fan, fap, fbm, fbq, i, z),
+ -1, fan + fap)
+ if op is not None:
+ ops += [op]
+ change = True
+ continue
+ op = try_shift(fan, to.an, lambda i: MeijerShiftB(fan[i]), -1, [])
+ if op is not None:
+ ops += [op]
+ change = True
+ continue
+ op = try_shift(fap, to.ap, lambda i: MeijerShiftD(fap[i]), -1, [])
+ if op is not None:
+ ops += [op]
+ change = True
+ continue
+ op = try_shift(fbm, to.bm, lambda i: MeijerShiftA(fbm[i]), 1, [])
+ if op is not None:
+ ops += [op]
+ change = True
+ continue
+ op = try_shift(fbq, to.bq, lambda i: MeijerShiftC(fbq[i]), 1, [])
+ if op is not None:
+ ops += [op]
+ change = True
+ continue
+ if fan != list(to.an) or fap != list(to.ap) or fbm != list(to.bm) or \
+ fbq != list(to.bq):
+ raise NotImplementedError('Could not devise plan.')
+ ops.reverse()
+ return ops
+
+_meijercollection = None
+
+
+def _meijergexpand(func, z0, allow_hyper=False, rewrite='default',
+ place=None):
+ """
+ Try to find an expression for the Meijer G function specified
+ by the G_Function ``func``. If ``allow_hyper`` is True, then returning
+ an expression in terms of hypergeometric functions is allowed.
+
+ Currently this just does Slater's theorem.
+ If expansions exist both at zero and at infinity, ``place``
+ can be set to ``0`` or ``zoo`` for the preferred choice.
+ """
+ global _meijercollection
+ if _meijercollection is None:
+ _meijercollection = MeijerFormulaCollection()
+ if rewrite == 'default':
+ rewrite = None
+
+ func0 = func
+ debug('Try to expand Meijer G function corresponding to ', func)
+
+ # We will play games with analytic continuation - rather use a fresh symbol
+ z = Dummy('z')
+
+ func, ops = reduce_order_meijer(func)
+ if ops:
+ debug(' Reduced order to ', func)
+ else:
+ debug(' Could not reduce order.')
+
+ # Try to find a direct formula
+ f = _meijercollection.lookup_origin(func)
+ if f is not None:
+ debug(' Found a Meijer G formula: ', f.func)
+ ops += devise_plan_meijer(f.func, func, z)
+
+ # Now carry out the plan.
+ C = apply_operators(f.C.subs(f.z, z), ops,
+ make_derivative_operator(f.M.subs(f.z, z), z))
+
+ C = C.applyfunc(make_simp(z))
+ r = C*f.B.subs(f.z, z)
+ r = r[0].subs(z, z0)
+ return powdenest(r, polar=True)
+
+ debug(" Could not find a direct formula. Trying Slater's theorem.")
+
+ # TODO the following would be possible:
+ # *) Paired Index Theorems
+ # *) PFD Duplication
+ # (See Kelly Roach's paper for details on either.)
+ #
+ # TODO Also, we tend to create combinations of gamma functions that can be
+ # simplified.
+
+ def can_do(pbm, pap):
+ """ Test if slater applies. """
+ for i in pbm:
+ if len(pbm[i]) > 1:
+ l = 0
+ if i in pap:
+ l = len(pap[i])
+ if l + 1 < len(pbm[i]):
+ return False
+ return True
+
+ def do_slater(an, bm, ap, bq, z, zfinal):
+ # zfinal is the value that will eventually be substituted for z.
+ # We pass it to _hyperexpand to improve performance.
+ func = G_Function(an, bm, ap, bq)
+ _, pbm, pap, _ = func.compute_buckets()
+ if not can_do(pbm, pap):
+ return S.Zero, False
+
+ cond = len(an) + len(ap) < len(bm) + len(bq)
+ if len(an) + len(ap) == len(bm) + len(bq):
+ cond = abs(z) < 1
+ if cond is False:
+ return S.Zero, False
+
+ res = S.Zero
+ for m in pbm:
+ if len(pbm[m]) == 1:
+ bh = pbm[m][0]
+ fac = 1
+ bo = list(bm)
+ bo.remove(bh)
+ for bj in bo:
+ fac *= gamma(bj - bh)
+ for aj in an:
+ fac *= gamma(1 + bh - aj)
+ for bj in bq:
+ fac /= gamma(1 + bh - bj)
+ for aj in ap:
+ fac /= gamma(aj - bh)
+ nap = [1 + bh - a for a in list(an) + list(ap)]
+ nbq = [1 + bh - b for b in list(bo) + list(bq)]
+
+ k = polar_lift(S.NegativeOne**(len(ap) - len(bm)))
+ harg = k*zfinal
+ # NOTE even though k "is" +-1, this has to be t/k instead of
+ # t*k ... we are using polar numbers for consistency!
+ premult = (t/k)**bh
+ hyp = _hyperexpand(Hyper_Function(nap, nbq), harg, ops,
+ t, premult, bh, rewrite=None)
+ res += fac * hyp
+ else:
+ b_ = pbm[m][0]
+ ki = [bi - b_ for bi in pbm[m][1:]]
+ u = len(ki)
+ li = [ai - b_ for ai in pap[m][:u + 1]]
+ bo = list(bm)
+ for b in pbm[m]:
+ bo.remove(b)
+ ao = list(ap)
+ for a in pap[m][:u]:
+ ao.remove(a)
+ lu = li[-1]
+ di = [l - k for (l, k) in zip(li, ki)]
+
+ # We first work out the integrand:
+ s = Dummy('s')
+ integrand = z**s
+ for b in bm:
+ if not Mod(b, 1) and b.is_Number:
+ b = int(round(b))
+ integrand *= gamma(b - s)
+ for a in an:
+ integrand *= gamma(1 - a + s)
+ for b in bq:
+ integrand /= gamma(1 - b + s)
+ for a in ap:
+ integrand /= gamma(a - s)
+
+ # Now sum the finitely many residues:
+ # XXX This speeds up some cases - is it a good idea?
+ integrand = expand_func(integrand)
+ for r in range(int(round(lu))):
+ resid = residue(integrand, s, b_ + r)
+ resid = apply_operators(resid, ops, lambda f: z*f.diff(z))
+ res -= resid
+
+ # Now the hypergeometric term.
+ au = b_ + lu
+ k = polar_lift(S.NegativeOne**(len(ao) + len(bo) + 1))
+ harg = k*zfinal
+ premult = (t/k)**au
+ nap = [1 + au - a for a in list(an) + list(ap)] + [1]
+ nbq = [1 + au - b for b in list(bm) + list(bq)]
+
+ hyp = _hyperexpand(Hyper_Function(nap, nbq), harg, ops,
+ t, premult, au, rewrite=None)
+
+ C = S.NegativeOne**(lu)/factorial(lu)
+ for i in range(u):
+ C *= S.NegativeOne**di[i]/rf(lu - li[i] + 1, di[i])
+ for a in an:
+ C *= gamma(1 - a + au)
+ for b in bo:
+ C *= gamma(b - au)
+ for a in ao:
+ C /= gamma(a - au)
+ for b in bq:
+ C /= gamma(1 - b + au)
+
+ res += C*hyp
+
+ return res, cond
+
+ t = Dummy('t')
+ slater1, cond1 = do_slater(func.an, func.bm, func.ap, func.bq, z, z0)
+
+ def tr(l):
+ return [1 - x for x in l]
+
+ for op in ops:
+ op._poly = Poly(op._poly.subs({z: 1/t, _x: -_x}), _x)
+ slater2, cond2 = do_slater(tr(func.bm), tr(func.an), tr(func.bq), tr(func.ap),
+ t, 1/z0)
+
+ slater1 = powdenest(slater1.subs(z, z0), polar=True)
+ slater2 = powdenest(slater2.subs(t, 1/z0), polar=True)
+ if not isinstance(cond2, bool):
+ cond2 = cond2.subs(t, 1/z)
+
+ m = func(z)
+ if m.delta > 0 or \
+ (m.delta == 0 and len(m.ap) == len(m.bq) and
+ (re(m.nu) < -1) is not False and polar_lift(z0) == polar_lift(1)):
+ # The condition delta > 0 means that the convergence region is
+ # connected. Any expression we find can be continued analytically
+ # to the entire convergence region.
+ # The conditions delta==0, p==q, re(nu) < -1 imply that G is continuous
+ # on the positive reals, so the values at z=1 agree.
+ if cond1 is not False:
+ cond1 = True
+ if cond2 is not False:
+ cond2 = True
+
+ if cond1 is True:
+ slater1 = slater1.rewrite(rewrite or 'nonrep')
+ else:
+ slater1 = slater1.rewrite(rewrite or 'nonrepsmall')
+ if cond2 is True:
+ slater2 = slater2.rewrite(rewrite or 'nonrep')
+ else:
+ slater2 = slater2.rewrite(rewrite or 'nonrepsmall')
+
+ if cond1 is not False and cond2 is not False:
+ # If one condition is False, there is no choice.
+ if place == 0:
+ cond2 = False
+ if place == zoo:
+ cond1 = False
+
+ if not isinstance(cond1, bool):
+ cond1 = cond1.subs(z, z0)
+ if not isinstance(cond2, bool):
+ cond2 = cond2.subs(z, z0)
+
+ def weight(expr, cond):
+ if cond is True:
+ c0 = 0
+ elif cond is False:
+ c0 = 1
+ else:
+ c0 = 2
+ if expr.has(oo, zoo, -oo, nan):
+ # XXX this actually should not happen, but consider
+ # S('meijerg(((0, -1/2, 0, -1/2, 1/2), ()), ((0,),
+ # (-1/2, -1/2, -1/2, -1)), exp_polar(I*pi))/4')
+ c0 = 3
+ return (c0, expr.count(hyper), expr.count_ops())
+
+ w1 = weight(slater1, cond1)
+ w2 = weight(slater2, cond2)
+ if min(w1, w2) <= (0, 1, oo):
+ if w1 < w2:
+ return slater1
+ else:
+ return slater2
+ if max(w1[0], w2[0]) <= 1 and max(w1[1], w2[1]) <= 1:
+ return Piecewise((slater1, cond1), (slater2, cond2), (func0(z0), True))
+
+ # We couldn't find an expression without hypergeometric functions.
+ # TODO it would be helpful to give conditions under which the integral
+ # is known to diverge.
+ r = Piecewise((slater1, cond1), (slater2, cond2), (func0(z0), True))
+ if r.has(hyper) and not allow_hyper:
+ debug(' Could express using hypergeometric functions, '
+ 'but not allowed.')
+ if not r.has(hyper) or allow_hyper:
+ return r
+
+ return func0(z0)
+
+
+def hyperexpand(f, allow_hyper=False, rewrite='default', place=None):
+ """
+ Expand hypergeometric functions. If allow_hyper is True, allow partial
+ simplification (that is a result different from input,
+ but still containing hypergeometric functions).
+
+ If a G-function has expansions both at zero and at infinity,
+ ``place`` can be set to ``0`` or ``zoo`` to indicate the
+ preferred choice.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.hyperexpand import hyperexpand
+ >>> from sympy.functions import hyper
+ >>> from sympy.abc import z
+ >>> hyperexpand(hyper([], [], z))
+ exp(z)
+
+ Non-hyperegeometric parts of the expression and hypergeometric expressions
+ that are not recognised are left unchanged:
+
+ >>> hyperexpand(1 + hyper([1, 1, 1], [], z))
+ hyper((1, 1, 1), (), z) + 1
+ """
+ f = sympify(f)
+
+ def do_replace(ap, bq, z):
+ r = _hyperexpand(Hyper_Function(ap, bq), z, rewrite=rewrite)
+ if r is None:
+ return hyper(ap, bq, z)
+ else:
+ return r
+
+ def do_meijer(ap, bq, z):
+ r = _meijergexpand(G_Function(ap[0], ap[1], bq[0], bq[1]), z,
+ allow_hyper, rewrite=rewrite, place=place)
+ if not r.has(nan, zoo, oo, -oo):
+ return r
+ return f.replace(hyper, do_replace).replace(meijerg, do_meijer)
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/ratsimp.py b/vllm/lib/python3.10/site-packages/sympy/simplify/ratsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..95751fab47f585d3ae2e1289f014fba0f2708224
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/ratsimp.py
@@ -0,0 +1,222 @@
+from itertools import combinations_with_replacement
+from sympy.core import symbols, Add, Dummy
+from sympy.core.numbers import Rational
+from sympy.polys import cancel, ComputationFailed, parallel_poly_from_expr, reduced, Poly
+from sympy.polys.monomials import Monomial, monomial_div
+from sympy.polys.polyerrors import DomainError, PolificationFailed
+from sympy.utilities.misc import debug, debugf
+
+def ratsimp(expr):
+ """
+ Put an expression over a common denominator, cancel and reduce.
+
+ Examples
+ ========
+
+ >>> from sympy import ratsimp
+ >>> from sympy.abc import x, y
+ >>> ratsimp(1/x + 1/y)
+ (x + y)/(x*y)
+ """
+
+ f, g = cancel(expr).as_numer_denom()
+ try:
+ Q, r = reduced(f, [g], field=True, expand=False)
+ except ComputationFailed:
+ return f/g
+
+ return Add(*Q) + cancel(r/g)
+
+
+def ratsimpmodprime(expr, G, *gens, quick=True, polynomial=False, **args):
+ """
+ Simplifies a rational expression ``expr`` modulo the prime ideal
+ generated by ``G``. ``G`` should be a Groebner basis of the
+ ideal.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.ratsimp import ratsimpmodprime
+ >>> from sympy.abc import x, y
+ >>> eq = (x + y**5 + y)/(x - y)
+ >>> ratsimpmodprime(eq, [x*y**5 - x - y], x, y, order='lex')
+ (-x**2 - x*y - x - y)/(-x**2 + x*y)
+
+ If ``polynomial`` is ``False``, the algorithm computes a rational
+ simplification which minimizes the sum of the total degrees of
+ the numerator and the denominator.
+
+ If ``polynomial`` is ``True``, this function just brings numerator and
+ denominator into a canonical form. This is much faster, but has
+ potentially worse results.
+
+ References
+ ==========
+
+ .. [1] M. Monagan, R. Pearce, Rational Simplification Modulo a Polynomial
+ Ideal, https://dl.acm.org/doi/pdf/10.1145/1145768.1145809
+ (specifically, the second algorithm)
+ """
+ from sympy.solvers.solvers import solve
+
+ debug('ratsimpmodprime', expr)
+
+ # usual preparation of polynomials:
+
+ num, denom = cancel(expr).as_numer_denom()
+
+ try:
+ polys, opt = parallel_poly_from_expr([num, denom] + G, *gens, **args)
+ except PolificationFailed:
+ return expr
+
+ domain = opt.domain
+
+ if domain.has_assoc_Field:
+ opt.domain = domain.get_field()
+ else:
+ raise DomainError(
+ "Cannot compute rational simplification over %s" % domain)
+
+ # compute only once
+ leading_monomials = [g.LM(opt.order) for g in polys[2:]]
+ tested = set()
+
+ def staircase(n):
+ """
+ Compute all monomials with degree less than ``n`` that are
+ not divisible by any element of ``leading_monomials``.
+ """
+ if n == 0:
+ return [1]
+ S = []
+ for mi in combinations_with_replacement(range(len(opt.gens)), n):
+ m = [0]*len(opt.gens)
+ for i in mi:
+ m[i] += 1
+ if all(monomial_div(m, lmg) is None for lmg in
+ leading_monomials):
+ S.append(m)
+
+ return [Monomial(s).as_expr(*opt.gens) for s in S] + staircase(n - 1)
+
+ def _ratsimpmodprime(a, b, allsol, N=0, D=0):
+ r"""
+ Computes a rational simplification of ``a/b`` which minimizes
+ the sum of the total degrees of the numerator and the denominator.
+
+ Explanation
+ ===========
+
+ The algorithm proceeds by looking at ``a * d - b * c`` modulo
+ the ideal generated by ``G`` for some ``c`` and ``d`` with degree
+ less than ``a`` and ``b`` respectively.
+ The coefficients of ``c`` and ``d`` are indeterminates and thus
+ the coefficients of the normalform of ``a * d - b * c`` are
+ linear polynomials in these indeterminates.
+ If these linear polynomials, considered as system of
+ equations, have a nontrivial solution, then `\frac{a}{b}
+ \equiv \frac{c}{d}` modulo the ideal generated by ``G``. So,
+ by construction, the degree of ``c`` and ``d`` is less than
+ the degree of ``a`` and ``b``, so a simpler representation
+ has been found.
+ After a simpler representation has been found, the algorithm
+ tries to reduce the degree of the numerator and denominator
+ and returns the result afterwards.
+
+ As an extension, if quick=False, we look at all possible degrees such
+ that the total degree is less than *or equal to* the best current
+ solution. We retain a list of all solutions of minimal degree, and try
+ to find the best one at the end.
+ """
+ c, d = a, b
+ steps = 0
+
+ maxdeg = a.total_degree() + b.total_degree()
+ if quick:
+ bound = maxdeg - 1
+ else:
+ bound = maxdeg
+ while N + D <= bound:
+ if (N, D) in tested:
+ break
+ tested.add((N, D))
+
+ M1 = staircase(N)
+ M2 = staircase(D)
+ debugf('%s / %s: %s, %s', (N, D, M1, M2))
+
+ Cs = symbols("c:%d" % len(M1), cls=Dummy)
+ Ds = symbols("d:%d" % len(M2), cls=Dummy)
+ ng = Cs + Ds
+
+ c_hat = Poly(
+ sum(Cs[i] * M1[i] for i in range(len(M1))), opt.gens + ng)
+ d_hat = Poly(
+ sum(Ds[i] * M2[i] for i in range(len(M2))), opt.gens + ng)
+
+ r = reduced(a * d_hat - b * c_hat, G, opt.gens + ng,
+ order=opt.order, polys=True)[1]
+
+ S = Poly(r, gens=opt.gens).coeffs()
+ sol = solve(S, Cs + Ds, particular=True, quick=True)
+
+ if sol and not all(s == 0 for s in sol.values()):
+ c = c_hat.subs(sol)
+ d = d_hat.subs(sol)
+
+ # The "free" variables occurring before as parameters
+ # might still be in the substituted c, d, so set them
+ # to the value chosen before:
+ c = c.subs(dict(list(zip(Cs + Ds, [1] * (len(Cs) + len(Ds))))))
+ d = d.subs(dict(list(zip(Cs + Ds, [1] * (len(Cs) + len(Ds))))))
+
+ c = Poly(c, opt.gens)
+ d = Poly(d, opt.gens)
+ if d == 0:
+ raise ValueError('Ideal not prime?')
+
+ allsol.append((c_hat, d_hat, S, Cs + Ds))
+ if N + D != maxdeg:
+ allsol = [allsol[-1]]
+
+ break
+
+ steps += 1
+ N += 1
+ D += 1
+
+ if steps > 0:
+ c, d, allsol = _ratsimpmodprime(c, d, allsol, N, D - steps)
+ c, d, allsol = _ratsimpmodprime(c, d, allsol, N - steps, D)
+
+ return c, d, allsol
+
+ # preprocessing. this improves performance a bit when deg(num)
+ # and deg(denom) are large:
+ num = reduced(num, G, opt.gens, order=opt.order)[1]
+ denom = reduced(denom, G, opt.gens, order=opt.order)[1]
+
+ if polynomial:
+ return (num/denom).cancel()
+
+ c, d, allsol = _ratsimpmodprime(
+ Poly(num, opt.gens, domain=opt.domain), Poly(denom, opt.gens, domain=opt.domain), [])
+ if not quick and allsol:
+ debugf('Looking for best minimal solution. Got: %s', len(allsol))
+ newsol = []
+ for c_hat, d_hat, S, ng in allsol:
+ sol = solve(S, ng, particular=True, quick=False)
+ # all values of sol should be numbers; if not, solve is broken
+ newsol.append((c_hat.subs(sol), d_hat.subs(sol)))
+ c, d = min(newsol, key=lambda x: len(x[0].terms()) + len(x[1].terms()))
+
+ if not domain.is_Field:
+ cn, c = c.clear_denoms(convert=True)
+ dn, d = d.clear_denoms(convert=True)
+ r = Rational(cn, dn)
+ else:
+ r = Rational(1)
+
+ return (c*r.q)/(d*r.p)
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__init__.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/__init__.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..01418006e38e44fc7058a365aa593e7d7c04c8b7
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_combsimp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_combsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..14e33bc72a30787ace7becae3ea444f4a9bd2182
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_combsimp.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_cse.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_cse.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9fa275db82a260f1dd88bc11666ef30c1e2a3ded
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_cse.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_epathtools.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_epathtools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7fdb154b1a4f4077e2ce146e6efbeb3f7005d855
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_epathtools.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_fu.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_fu.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ae8b17ec18556d320e149da65b8217163d0272a8
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_fu.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_function.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_function.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2d8e92a9b02ecf03372af26826db791a50bcaf08
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_function.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_gammasimp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_gammasimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ee9e8791471847541af543c2acf4f44443a56a8
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_gammasimp.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_hyperexpand.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_hyperexpand.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e36609abfcf2f445be1b8ffd6672c7f6c3050884
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_hyperexpand.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_powsimp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_powsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..10c5211cae3473dcc6091589f2d21aa28363f376
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_powsimp.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_radsimp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_radsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aa7108462c32709b8ef64ab74cda9b26eb8665e7
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_radsimp.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_ratsimp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_ratsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ecceaef7480cbca9f923ac0779747941a6c1b780
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_ratsimp.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_rewrite.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_rewrite.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b7be2fdeec664d6a425dc80346a5d041f8b2e511
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_rewrite.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_simplify.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_simplify.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b1b0531d66c66feea95f38149f1865e2f0447bc5
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_simplify.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_sqrtdenest.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_sqrtdenest.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..45d845f531da02c88c1eba08b47d00aa9cc2b160
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_sqrtdenest.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_trigsimp.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_trigsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd500ee544b598a67977aeb5d636bc93ab40b913
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_trigsimp.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_combsimp.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_combsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..e56758a005fbb013c2b6ea4121b16c3434a54b03
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_combsimp.py
@@ -0,0 +1,75 @@
+from sympy.core.numbers import Rational
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import (FallingFactorial, RisingFactorial, binomial, factorial)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.simplify.combsimp import combsimp
+from sympy.abc import x
+
+
+def test_combsimp():
+ k, m, n = symbols('k m n', integer = True)
+
+ assert combsimp(factorial(n)) == factorial(n)
+ assert combsimp(binomial(n, k)) == binomial(n, k)
+
+ assert combsimp(factorial(n)/factorial(n - 3)) == n*(-1 + n)*(-2 + n)
+ assert combsimp(binomial(n + 1, k + 1)/binomial(n, k)) == (1 + n)/(1 + k)
+
+ assert combsimp(binomial(3*n + 4, n + 1)/binomial(3*n + 1, n)) == \
+ Rational(3, 2)*((3*n + 2)*(3*n + 4)/((n + 1)*(2*n + 3)))
+
+ assert combsimp(factorial(n)**2/factorial(n - 3)) == \
+ factorial(n)*n*(-1 + n)*(-2 + n)
+ assert combsimp(factorial(n)*binomial(n + 1, k + 1)/binomial(n, k)) == \
+ factorial(n + 1)/(1 + k)
+
+ assert combsimp(gamma(n + 3)) == factorial(n + 2)
+
+ assert combsimp(factorial(x)) == gamma(x + 1)
+
+ # issue 9699
+ assert combsimp((n + 1)*factorial(n)) == factorial(n + 1)
+ assert combsimp(factorial(n)/n) == factorial(n-1)
+
+ # issue 6658
+ assert combsimp(binomial(n, n - k)) == binomial(n, k)
+
+ # issue 6341, 7135
+ assert combsimp(factorial(n)/(factorial(k)*factorial(n - k))) == \
+ binomial(n, k)
+ assert combsimp(factorial(k)*factorial(n - k)/factorial(n)) == \
+ 1/binomial(n, k)
+ assert combsimp(factorial(2*n)/factorial(n)**2) == binomial(2*n, n)
+ assert combsimp(factorial(2*n)*factorial(k)*factorial(n - k)/
+ factorial(n)**3) == binomial(2*n, n)/binomial(n, k)
+
+ assert combsimp(factorial(n*(1 + n) - n**2 - n)) == 1
+
+ assert combsimp(6*FallingFactorial(-4, n)/factorial(n)) == \
+ (-1)**n*(n + 1)*(n + 2)*(n + 3)
+ assert combsimp(6*FallingFactorial(-4, n - 1)/factorial(n - 1)) == \
+ (-1)**(n - 1)*n*(n + 1)*(n + 2)
+ assert combsimp(6*FallingFactorial(-4, n - 3)/factorial(n - 3)) == \
+ (-1)**(n - 3)*n*(n - 1)*(n - 2)
+ assert combsimp(6*FallingFactorial(-4, -n - 1)/factorial(-n - 1)) == \
+ -(-1)**(-n - 1)*n*(n - 1)*(n - 2)
+
+ assert combsimp(6*RisingFactorial(4, n)/factorial(n)) == \
+ (n + 1)*(n + 2)*(n + 3)
+ assert combsimp(6*RisingFactorial(4, n - 1)/factorial(n - 1)) == \
+ n*(n + 1)*(n + 2)
+ assert combsimp(6*RisingFactorial(4, n - 3)/factorial(n - 3)) == \
+ n*(n - 1)*(n - 2)
+ assert combsimp(6*RisingFactorial(4, -n - 1)/factorial(-n - 1)) == \
+ -n*(n - 1)*(n - 2)
+
+
+def test_issue_6878():
+ n = symbols('n', integer=True)
+ assert combsimp(RisingFactorial(-10, n)) == 3628800*(-1)**n/factorial(10 - n)
+
+
+def test_issue_14528():
+ p = symbols("p", integer=True, positive=True)
+ assert combsimp(binomial(1,p)) == 1/(factorial(p)*factorial(1-p))
+ assert combsimp(factorial(2-p)) == factorial(2-p)
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_cse.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_cse.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e3955252ee65b1f7d949c23822508b7ef0a0dd9
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_cse.py
@@ -0,0 +1,758 @@
+from functools import reduce
+import itertools
+from operator import add
+
+from sympy.codegen.matrix_nodes import MatrixSolve
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.expr import UnevaluatedExpr
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions import Inverse, MatAdd, MatMul, Transpose
+from sympy.polys.rootoftools import CRootOf
+from sympy.series.order import O
+from sympy.simplify.cse_main import cse
+from sympy.simplify.simplify import signsimp
+from sympy.tensor.indexed import (Idx, IndexedBase)
+
+from sympy.core.function import count_ops
+from sympy.simplify.cse_opts import sub_pre, sub_post
+from sympy.functions.special.hyper import meijerg
+from sympy.simplify import cse_main, cse_opts
+from sympy.utilities.iterables import subsets
+from sympy.testing.pytest import XFAIL, raises
+from sympy.matrices import (MutableDenseMatrix, MutableSparseMatrix,
+ ImmutableDenseMatrix, ImmutableSparseMatrix)
+from sympy.matrices.expressions import MatrixSymbol
+
+
+w, x, y, z = symbols('w,x,y,z')
+x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12 = symbols('x:13')
+
+
+def test_numbered_symbols():
+ ns = cse_main.numbered_symbols(prefix='y')
+ assert list(itertools.islice(
+ ns, 0, 10)) == [Symbol('y%s' % i) for i in range(0, 10)]
+ ns = cse_main.numbered_symbols(prefix='y')
+ assert list(itertools.islice(
+ ns, 10, 20)) == [Symbol('y%s' % i) for i in range(10, 20)]
+ ns = cse_main.numbered_symbols()
+ assert list(itertools.islice(
+ ns, 0, 10)) == [Symbol('x%s' % i) for i in range(0, 10)]
+
+# Dummy "optimization" functions for testing.
+
+
+def opt1(expr):
+ return expr + y
+
+
+def opt2(expr):
+ return expr*z
+
+
+def test_preprocess_for_cse():
+ assert cse_main.preprocess_for_cse(x, [(opt1, None)]) == x + y
+ assert cse_main.preprocess_for_cse(x, [(None, opt1)]) == x
+ assert cse_main.preprocess_for_cse(x, [(None, None)]) == x
+ assert cse_main.preprocess_for_cse(x, [(opt1, opt2)]) == x + y
+ assert cse_main.preprocess_for_cse(
+ x, [(opt1, None), (opt2, None)]) == (x + y)*z
+
+
+def test_postprocess_for_cse():
+ assert cse_main.postprocess_for_cse(x, [(opt1, None)]) == x
+ assert cse_main.postprocess_for_cse(x, [(None, opt1)]) == x + y
+ assert cse_main.postprocess_for_cse(x, [(None, None)]) == x
+ assert cse_main.postprocess_for_cse(x, [(opt1, opt2)]) == x*z
+ # Note the reverse order of application.
+ assert cse_main.postprocess_for_cse(
+ x, [(None, opt1), (None, opt2)]) == x*z + y
+
+
+def test_cse_single():
+ # Simple substitution.
+ e = Add(Pow(x + y, 2), sqrt(x + y))
+ substs, reduced = cse([e])
+ assert substs == [(x0, x + y)]
+ assert reduced == [sqrt(x0) + x0**2]
+
+ subst42, (red42,) = cse([42]) # issue_15082
+ assert len(subst42) == 0 and red42 == 42
+ subst_half, (red_half,) = cse([0.5])
+ assert len(subst_half) == 0 and red_half == 0.5
+
+
+def test_cse_single2():
+ # Simple substitution, test for being able to pass the expression directly
+ e = Add(Pow(x + y, 2), sqrt(x + y))
+ substs, reduced = cse(e)
+ assert substs == [(x0, x + y)]
+ assert reduced == [sqrt(x0) + x0**2]
+ substs, reduced = cse(Matrix([[1]]))
+ assert isinstance(reduced[0], Matrix)
+
+ subst42, (red42,) = cse(42) # issue 15082
+ assert len(subst42) == 0 and red42 == 42
+ subst_half, (red_half,) = cse(0.5) # issue 15082
+ assert len(subst_half) == 0 and red_half == 0.5
+
+
+def test_cse_not_possible():
+ # No substitution possible.
+ e = Add(x, y)
+ substs, reduced = cse([e])
+ assert substs == []
+ assert reduced == [x + y]
+ # issue 6329
+ eq = (meijerg((1, 2), (y, 4), (5,), [], x) +
+ meijerg((1, 3), (y, 4), (5,), [], x))
+ assert cse(eq) == ([], [eq])
+
+
+def test_nested_substitution():
+ # Substitution within a substitution.
+ e = Add(Pow(w*x + y, 2), sqrt(w*x + y))
+ substs, reduced = cse([e])
+ assert substs == [(x0, w*x + y)]
+ assert reduced == [sqrt(x0) + x0**2]
+
+
+def test_subtraction_opt():
+ # Make sure subtraction is optimized.
+ e = (x - y)*(z - y) + exp((x - y)*(z - y))
+ substs, reduced = cse(
+ [e], optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)])
+ assert substs == [(x0, (x - y)*(y - z))]
+ assert reduced == [-x0 + exp(-x0)]
+ e = -(x - y)*(z - y) + exp(-(x - y)*(z - y))
+ substs, reduced = cse(
+ [e], optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)])
+ assert substs == [(x0, (x - y)*(y - z))]
+ assert reduced == [x0 + exp(x0)]
+ # issue 4077
+ n = -1 + 1/x
+ e = n/x/(-n)**2 - 1/n/x
+ assert cse(e, optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)]) == \
+ ([], [0])
+ assert cse(((w + x + y + z)*(w - y - z))/(w + x)**3) == \
+ ([(x0, w + x), (x1, y + z)], [(w - x1)*(x0 + x1)/x0**3])
+
+
+def test_multiple_expressions():
+ e1 = (x + y)*z
+ e2 = (x + y)*w
+ substs, reduced = cse([e1, e2])
+ assert substs == [(x0, x + y)]
+ assert reduced == [x0*z, x0*w]
+ l = [w*x*y + z, w*y]
+ substs, reduced = cse(l)
+ rsubsts, _ = cse(reversed(l))
+ assert substs == rsubsts
+ assert reduced == [z + x*x0, x0]
+ l = [w*x*y, w*x*y + z, w*y]
+ substs, reduced = cse(l)
+ rsubsts, _ = cse(reversed(l))
+ assert substs == rsubsts
+ assert reduced == [x1, x1 + z, x0]
+ l = [(x - z)*(y - z), x - z, y - z]
+ substs, reduced = cse(l)
+ rsubsts, _ = cse(reversed(l))
+ assert substs == [(x0, -z), (x1, x + x0), (x2, x0 + y)]
+ assert rsubsts == [(x0, -z), (x1, x0 + y), (x2, x + x0)]
+ assert reduced == [x1*x2, x1, x2]
+ l = [w*y + w + x + y + z, w*x*y]
+ assert cse(l) == ([(x0, w*y)], [w + x + x0 + y + z, x*x0])
+ assert cse([x + y, x + y + z]) == ([(x0, x + y)], [x0, z + x0])
+ assert cse([x + y, x + z]) == ([], [x + y, x + z])
+ assert cse([x*y, z + x*y, x*y*z + 3]) == \
+ ([(x0, x*y)], [x0, z + x0, 3 + x0*z])
+
+
+@XFAIL # CSE of non-commutative Mul terms is disabled
+def test_non_commutative_cse():
+ A, B, C = symbols('A B C', commutative=False)
+ l = [A*B*C, A*C]
+ assert cse(l) == ([], l)
+ l = [A*B*C, A*B]
+ assert cse(l) == ([(x0, A*B)], [x0*C, x0])
+
+
+# Test if CSE of non-commutative Mul terms is disabled
+def test_bypass_non_commutatives():
+ A, B, C = symbols('A B C', commutative=False)
+ l = [A*B*C, A*C]
+ assert cse(l) == ([], l)
+ l = [A*B*C, A*B]
+ assert cse(l) == ([], l)
+ l = [B*C, A*B*C]
+ assert cse(l) == ([], l)
+
+
+@XFAIL # CSE fails when replacing non-commutative sub-expressions
+def test_non_commutative_order():
+ A, B, C = symbols('A B C', commutative=False)
+ x0 = symbols('x0', commutative=False)
+ l = [B+C, A*(B+C)]
+ assert cse(l) == ([(x0, B+C)], [x0, A*x0])
+
+
+@XFAIL # Worked in gh-11232, but was reverted due to performance considerations
+def test_issue_10228():
+ assert cse([x*y**2 + x*y]) == ([(x0, x*y)], [x0*y + x0])
+ assert cse([x + y, 2*x + y]) == ([(x0, x + y)], [x0, x + x0])
+ assert cse((w + 2*x + y + z, w + x + 1)) == (
+ [(x0, w + x)], [x0 + x + y + z, x0 + 1])
+ assert cse(((w + x + y + z)*(w - x))/(w + x)) == (
+ [(x0, w + x)], [(x0 + y + z)*(w - x)/x0])
+ a, b, c, d, f, g, j, m = symbols('a, b, c, d, f, g, j, m')
+ exprs = (d*g**2*j*m, 4*a*f*g*m, a*b*c*f**2)
+ assert cse(exprs) == (
+ [(x0, g*m), (x1, a*f)], [d*g*j*x0, 4*x0*x1, b*c*f*x1]
+)
+
+@XFAIL
+def test_powers():
+ assert cse(x*y**2 + x*y) == ([(x0, x*y)], [x0*y + x0])
+
+
+def test_issue_4498():
+ assert cse(w/(x - y) + z/(y - x), optimizations='basic') == \
+ ([], [(w - z)/(x - y)])
+
+
+def test_issue_4020():
+ assert cse(x**5 + x**4 + x**3 + x**2, optimizations='basic') \
+ == ([(x0, x**2)], [x0*(x**3 + x + x0 + 1)])
+
+
+def test_issue_4203():
+ assert cse(sin(x**x)/x**x) == ([(x0, x**x)], [sin(x0)/x0])
+
+
+def test_issue_6263():
+ e = Eq(x*(-x + 1) + x*(x - 1), 0)
+ assert cse(e, optimizations='basic') == ([], [True])
+
+
+def test_issue_25043():
+ c = symbols("c")
+ x = symbols("x0", real=True)
+ cse_expr = cse(c*x**2 + c*(x**4 - x**2))[-1][-1]
+ free = cse_expr.free_symbols
+ assert len(free) == len({i.name for i in free})
+
+
+def test_dont_cse_tuples():
+ from sympy.core.function import Subs
+ f = Function("f")
+ g = Function("g")
+
+ name_val, (expr,) = cse(
+ Subs(f(x, y), (x, y), (0, 1))
+ + Subs(g(x, y), (x, y), (0, 1)))
+
+ assert name_val == []
+ assert expr == (Subs(f(x, y), (x, y), (0, 1))
+ + Subs(g(x, y), (x, y), (0, 1)))
+
+ name_val, (expr,) = cse(
+ Subs(f(x, y), (x, y), (0, x + y))
+ + Subs(g(x, y), (x, y), (0, x + y)))
+
+ assert name_val == [(x0, x + y)]
+ assert expr == Subs(f(x, y), (x, y), (0, x0)) + \
+ Subs(g(x, y), (x, y), (0, x0))
+
+
+def test_pow_invpow():
+ assert cse(1/x**2 + x**2) == \
+ ([(x0, x**2)], [x0 + 1/x0])
+ assert cse(x**2 + (1 + 1/x**2)/x**2) == \
+ ([(x0, x**2), (x1, 1/x0)], [x0 + x1*(x1 + 1)])
+ assert cse(1/x**2 + (1 + 1/x**2)*x**2) == \
+ ([(x0, x**2), (x1, 1/x0)], [x0*(x1 + 1) + x1])
+ assert cse(cos(1/x**2) + sin(1/x**2)) == \
+ ([(x0, x**(-2))], [sin(x0) + cos(x0)])
+ assert cse(cos(x**2) + sin(x**2)) == \
+ ([(x0, x**2)], [sin(x0) + cos(x0)])
+ assert cse(y/(2 + x**2) + z/x**2/y) == \
+ ([(x0, x**2)], [y/(x0 + 2) + z/(x0*y)])
+ assert cse(exp(x**2) + x**2*cos(1/x**2)) == \
+ ([(x0, x**2)], [x0*cos(1/x0) + exp(x0)])
+ assert cse((1 + 1/x**2)/x**2) == \
+ ([(x0, x**(-2))], [x0*(x0 + 1)])
+ assert cse(x**(2*y) + x**(-2*y)) == \
+ ([(x0, x**(2*y))], [x0 + 1/x0])
+
+
+def test_postprocess():
+ eq = (x + 1 + exp((x + 1)/(y + 1)) + cos(y + 1))
+ assert cse([eq, Eq(x, z + 1), z - 2, (z + 1)*(x + 1)],
+ postprocess=cse_main.cse_separate) == \
+ [[(x0, y + 1), (x2, z + 1), (x, x2), (x1, x + 1)],
+ [x1 + exp(x1/x0) + cos(x0), z - 2, x1*x2]]
+
+
+def test_issue_4499():
+ # previously, this gave 16 constants
+ from sympy.abc import a, b
+ B = Function('B')
+ G = Function('G')
+ t = Tuple(*
+ (a, a + S.Half, 2*a, b, 2*a - b + 1, (sqrt(z)/2)**(-2*a + 1)*B(2*a -
+ b, sqrt(z))*B(b - 1, sqrt(z))*G(b)*G(2*a - b + 1),
+ sqrt(z)*(sqrt(z)/2)**(-2*a + 1)*B(b, sqrt(z))*B(2*a - b,
+ sqrt(z))*G(b)*G(2*a - b + 1), sqrt(z)*(sqrt(z)/2)**(-2*a + 1)*B(b - 1,
+ sqrt(z))*B(2*a - b + 1, sqrt(z))*G(b)*G(2*a - b + 1),
+ (sqrt(z)/2)**(-2*a + 1)*B(b, sqrt(z))*B(2*a - b + 1,
+ sqrt(z))*G(b)*G(2*a - b + 1), 1, 0, S.Half, z/2, -b + 1, -2*a + b,
+ -2*a))
+ c = cse(t)
+ ans = (
+ [(x0, 2*a), (x1, -b + x0), (x2, x1 + 1), (x3, b - 1), (x4, sqrt(z)),
+ (x5, B(x3, x4)), (x6, (x4/2)**(1 - x0)*G(b)*G(x2)), (x7, x6*B(x1, x4)),
+ (x8, B(b, x4)), (x9, x6*B(x2, x4))],
+ [(a, a + S.Half, x0, b, x2, x5*x7, x4*x7*x8, x4*x5*x9, x8*x9,
+ 1, 0, S.Half, z/2, -x3, -x1, -x0)])
+ assert ans == c
+
+
+def test_issue_6169():
+ r = CRootOf(x**6 - 4*x**5 - 2, 1)
+ assert cse(r) == ([], [r])
+ # and a check that the right thing is done with the new
+ # mechanism
+ assert sub_post(sub_pre((-x - y)*z - x - y)) == -z*(x + y) - x - y
+
+
+def test_cse_Indexed():
+ len_y = 5
+ y = IndexedBase('y', shape=(len_y,))
+ x = IndexedBase('x', shape=(len_y,))
+ i = Idx('i', len_y-1)
+
+ expr1 = (y[i+1]-y[i])/(x[i+1]-x[i])
+ expr2 = 1/(x[i+1]-x[i])
+ replacements, reduced_exprs = cse([expr1, expr2])
+ assert len(replacements) > 0
+
+
+def test_cse_MatrixSymbol():
+ # MatrixSymbols have non-Basic args, so make sure that works
+ A = MatrixSymbol("A", 3, 3)
+ assert cse(A) == ([], [A])
+
+ n = symbols('n', integer=True)
+ B = MatrixSymbol("B", n, n)
+ assert cse(B) == ([], [B])
+
+ assert cse(A[0] * A[0]) == ([], [A[0]*A[0]])
+
+ assert cse(A[0,0]*A[0,1] + A[0,0]*A[0,1]*A[0,2]) == ([(x0, A[0, 0]*A[0, 1])], [x0*A[0, 2] + x0])
+
+def test_cse_MatrixExpr():
+ A = MatrixSymbol('A', 3, 3)
+ y = MatrixSymbol('y', 3, 1)
+
+ expr1 = (A.T*A).I * A * y
+ expr2 = (A.T*A) * A * y
+ replacements, reduced_exprs = cse([expr1, expr2])
+ assert len(replacements) > 0
+
+ replacements, reduced_exprs = cse([expr1 + expr2, expr1])
+ assert replacements
+
+ replacements, reduced_exprs = cse([A**2, A + A**2])
+ assert replacements
+
+
+def test_Piecewise():
+ f = Piecewise((-z + x*y, Eq(y, 0)), (-z - x*y, True))
+ ans = cse(f)
+ actual_ans = ([(x0, x*y)],
+ [Piecewise((x0 - z, Eq(y, 0)), (-z - x0, True))])
+ assert ans == actual_ans
+
+
+def test_ignore_order_terms():
+ eq = exp(x).series(x,0,3) + sin(y+x**3) - 1
+ assert cse(eq) == ([], [sin(x**3 + y) + x + x**2/2 + O(x**3)])
+
+
+def test_name_conflict():
+ z1 = x0 + y
+ z2 = x2 + x3
+ l = [cos(z1) + z1, cos(z2) + z2, x0 + x2]
+ substs, reduced = cse(l)
+ assert [e.subs(reversed(substs)) for e in reduced] == l
+
+
+def test_name_conflict_cust_symbols():
+ z1 = x0 + y
+ z2 = x2 + x3
+ l = [cos(z1) + z1, cos(z2) + z2, x0 + x2]
+ substs, reduced = cse(l, symbols("x:10"))
+ assert [e.subs(reversed(substs)) for e in reduced] == l
+
+
+def test_symbols_exhausted_error():
+ l = cos(x+y)+x+y+cos(w+y)+sin(w+y)
+ sym = [x, y, z]
+ with raises(ValueError):
+ cse(l, symbols=sym)
+
+
+def test_issue_7840():
+ # daveknippers' example
+ C393 = sympify( \
+ 'Piecewise((C391 - 1.65, C390 < 0.5), (Piecewise((C391 - 1.65, \
+ C391 > 2.35), (C392, True)), True))'
+ )
+ C391 = sympify( \
+ 'Piecewise((2.05*C390**(-1.03), C390 < 0.5), (2.5*C390**(-0.625), True))'
+ )
+ C393 = C393.subs('C391',C391)
+ # simple substitution
+ sub = {}
+ sub['C390'] = 0.703451854
+ sub['C392'] = 1.01417794
+ ss_answer = C393.subs(sub)
+ # cse
+ substitutions,new_eqn = cse(C393)
+ for pair in substitutions:
+ sub[pair[0].name] = pair[1].subs(sub)
+ cse_answer = new_eqn[0].subs(sub)
+ # both methods should be the same
+ assert ss_answer == cse_answer
+
+ # GitRay's example
+ expr = sympify(
+ "Piecewise((Symbol('ON'), Equality(Symbol('mode'), Symbol('ON'))), \
+ (Piecewise((Piecewise((Symbol('OFF'), StrictLessThan(Symbol('x'), \
+ Symbol('threshold'))), (Symbol('ON'), true)), Equality(Symbol('mode'), \
+ Symbol('AUTO'))), (Symbol('OFF'), true)), true))"
+ )
+ substitutions, new_eqn = cse(expr)
+ # this Piecewise should be exactly the same
+ assert new_eqn[0] == expr
+ # there should not be any replacements
+ assert len(substitutions) < 1
+
+
+def test_issue_8891():
+ for cls in (MutableDenseMatrix, MutableSparseMatrix,
+ ImmutableDenseMatrix, ImmutableSparseMatrix):
+ m = cls(2, 2, [x + y, 0, 0, 0])
+ res = cse([x + y, m])
+ ans = ([(x0, x + y)], [x0, cls([[x0, 0], [0, 0]])])
+ assert res == ans
+ assert isinstance(res[1][-1], cls)
+
+
+def test_issue_11230():
+ # a specific test that always failed
+ a, b, f, k, l, i = symbols('a b f k l i')
+ p = [a*b*f*k*l, a*i*k**2*l, f*i*k**2*l]
+ R, C = cse(p)
+ assert not any(i.is_Mul for a in C for i in a.args)
+
+ # random tests for the issue
+ from sympy.core.random import choice
+ from sympy.core.function import expand_mul
+ s = symbols('a:m')
+ # 35 Mul tests, none of which should ever fail
+ ex = [Mul(*[choice(s) for i in range(5)]) for i in range(7)]
+ for p in subsets(ex, 3):
+ p = list(p)
+ R, C = cse(p)
+ assert not any(i.is_Mul for a in C for i in a.args)
+ for ri in reversed(R):
+ for i in range(len(C)):
+ C[i] = C[i].subs(*ri)
+ assert p == C
+ # 35 Add tests, none of which should ever fail
+ ex = [Add(*[choice(s[:7]) for i in range(5)]) for i in range(7)]
+ for p in subsets(ex, 3):
+ p = list(p)
+ R, C = cse(p)
+ assert not any(i.is_Add for a in C for i in a.args)
+ for ri in reversed(R):
+ for i in range(len(C)):
+ C[i] = C[i].subs(*ri)
+ # use expand_mul to handle cases like this:
+ # p = [a + 2*b + 2*e, 2*b + c + 2*e, b + 2*c + 2*g]
+ # x0 = 2*(b + e) is identified giving a rebuilt p that
+ # is now `[a + 2*(b + e), c + 2*(b + e), b + 2*c + 2*g]`
+ assert p == [expand_mul(i) for i in C]
+
+
+@XFAIL
+def test_issue_11577():
+ def check(eq):
+ r, c = cse(eq)
+ assert eq.count_ops() >= \
+ len(r) + sum(i[1].count_ops() for i in r) + \
+ count_ops(c)
+
+ eq = x**5*y**2 + x**5*y + x**5
+ assert cse(eq) == (
+ [(x0, x**4), (x1, x*y)], [x**5 + x0*x1*y + x0*x1])
+ # ([(x0, x**5*y)], [x0*y + x0 + x**5]) or
+ # ([(x0, x**5)], [x0*y**2 + x0*y + x0])
+ check(eq)
+
+ eq = x**2/(y + 1)**2 + x/(y + 1)
+ assert cse(eq) == (
+ [(x0, y + 1)], [x**2/x0**2 + x/x0])
+ # ([(x0, x/(y + 1))], [x0**2 + x0])
+ check(eq)
+
+
+def test_hollow_rejection():
+ eq = [x + 3, x + 4]
+ assert cse(eq) == ([], eq)
+
+
+def test_cse_ignore():
+ exprs = [exp(y)*(3*y + 3*sqrt(x+1)), exp(y)*(5*y + 5*sqrt(x+1))]
+ subst1, red1 = cse(exprs)
+ assert any(y in sub.free_symbols for _, sub in subst1), "cse failed to identify any term with y"
+
+ subst2, red2 = cse(exprs, ignore=(y,)) # y is not allowed in substitutions
+ assert not any(y in sub.free_symbols for _, sub in subst2), "Sub-expressions containing y must be ignored"
+ assert any(sub - sqrt(x + 1) == 0 for _, sub in subst2), "cse failed to identify sqrt(x + 1) as sub-expression"
+
+def test_cse_ignore_issue_15002():
+ l = [
+ w*exp(x)*exp(-z),
+ exp(y)*exp(x)*exp(-z)
+ ]
+ substs, reduced = cse(l, ignore=(x,))
+ rl = [e.subs(reversed(substs)) for e in reduced]
+ assert rl == l
+
+
+def test_cse_unevaluated():
+ xp1 = UnevaluatedExpr(x + 1)
+ # This used to cause RecursionError
+ [(x0, ue)], [red] = cse([(-1 - xp1) / (1 - xp1)])
+ if ue == xp1:
+ assert red == (-1 - x0) / (1 - x0)
+ elif ue == -xp1:
+ assert red == (-1 + x0) / (1 + x0)
+ else:
+ msg = f'Expected common subexpression {xp1} or {-xp1}, instead got {ue}'
+ assert False, msg
+
+
+def test_cse__performance():
+ nexprs, nterms = 3, 20
+ x = symbols('x:%d' % nterms)
+ exprs = [
+ reduce(add, [x[j]*(-1)**(i+j) for j in range(nterms)])
+ for i in range(nexprs)
+ ]
+ assert (exprs[0] + exprs[1]).simplify() == 0
+ subst, red = cse(exprs)
+ assert len(subst) > 0, "exprs[0] == -exprs[2], i.e. a CSE"
+ for i, e in enumerate(red):
+ assert (e.subs(reversed(subst)) - exprs[i]).simplify() == 0
+
+
+def test_issue_12070():
+ exprs = [x + y, 2 + x + y, x + y + z, 3 + x + y + z]
+ subst, red = cse(exprs)
+ assert 6 >= (len(subst) + sum(v.count_ops() for k, v in subst) +
+ count_ops(red))
+
+
+def test_issue_13000():
+ eq = x/(-4*x**2 + y**2)
+ cse_eq = cse(eq)[1][0]
+ assert cse_eq == eq
+
+
+def test_issue_18203():
+ eq = CRootOf(x**5 + 11*x - 2, 0) + CRootOf(x**5 + 11*x - 2, 1)
+ assert cse(eq) == ([], [eq])
+
+
+def test_unevaluated_mul():
+ eq = Mul(x + y, x + y, evaluate=False)
+ assert cse(eq) == ([(x0, x + y)], [x0**2])
+
+def test_cse_release_variables():
+ from sympy.simplify.cse_main import cse_release_variables
+ _0, _1, _2, _3, _4 = symbols('_:5')
+ eqs = [(x + y - 1)**2, x,
+ x + y, (x + y)/(2*x + 1) + (x + y - 1)**2,
+ (2*x + 1)**(x + y)]
+ r, e = cse(eqs, postprocess=cse_release_variables)
+ # this can change in keeping with the intention of the function
+ assert r, e == ([
+ (x0, x + y), (x1, (x0 - 1)**2), (x2, 2*x + 1),
+ (_3, x0/x2 + x1), (_4, x2**x0), (x2, None), (_0, x1),
+ (x1, None), (_2, x0), (x0, None), (_1, x)], (_0, _1, _2, _3, _4))
+ r.reverse()
+ r = [(s, v) for s, v in r if v is not None]
+ assert eqs == [i.subs(r) for i in e]
+
+def test_cse_list():
+ _cse = lambda x: cse(x, list=False)
+ assert _cse(x) == ([], x)
+ assert _cse('x') == ([], 'x')
+ it = [x]
+ for c in (list, tuple, set):
+ assert _cse(c(it)) == ([], c(it))
+ #Tuple works different from tuple:
+ assert _cse(Tuple(*it)) == ([], Tuple(*it))
+ d = {x: 1}
+ assert _cse(d) == ([], d)
+
+def test_issue_18991():
+ A = MatrixSymbol('A', 2, 2)
+ assert signsimp(-A * A - A) == -A * A - A
+
+
+def test_unevaluated_Mul():
+ m = [Mul(1, 2, evaluate=False)]
+ assert cse(m) == ([], m)
+
+
+def test_cse_matrix_expression_inverse():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ x = Inverse(A)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [Inverse(A)])
+
+
+def test_cse_matrix_expression_matmul_inverse():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ b = ImmutableDenseMatrix(symbols('b:2'))
+ x = MatMul(Inverse(A), b)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [x])
+
+
+def test_cse_matrix_negate_matrix():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ x = MatMul(S.NegativeOne, A)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [x])
+
+
+def test_cse_matrix_negate_matmul_not_extracted():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ B = ImmutableDenseMatrix(symbols('B:4')).reshape(2, 2)
+ x = MatMul(S.NegativeOne, A, B)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [x])
+
+
+@XFAIL # No simplification rule for nested associative operations
+def test_cse_matrix_nested_matmul_collapsed():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ B = ImmutableDenseMatrix(symbols('B:4')).reshape(2, 2)
+ x = MatMul(S.NegativeOne, MatMul(A, B))
+ cse_expr = cse(x)
+ assert cse_expr == ([], [MatMul(S.NegativeOne, A, B)])
+
+
+def test_cse_matrix_optimize_out_single_argument_mul():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ x = MatMul(MatMul(MatMul(A)))
+ cse_expr = cse(x)
+ assert cse_expr == ([], [A])
+
+
+@XFAIL # Multiple simplification passed not supported in CSE
+def test_cse_matrix_optimize_out_single_argument_mul_combined():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ x = MatAdd(MatMul(MatMul(MatMul(A))), MatMul(MatMul(A)), MatMul(A), A)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [MatMul(4, A)])
+
+
+def test_cse_matrix_optimize_out_single_argument_add():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ x = MatAdd(MatAdd(MatAdd(MatAdd(A))))
+ cse_expr = cse(x)
+ assert cse_expr == ([], [A])
+
+
+@XFAIL # Multiple simplification passed not supported in CSE
+def test_cse_matrix_optimize_out_single_argument_add_combined():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ x = MatMul(MatAdd(MatAdd(MatAdd(A))), MatAdd(MatAdd(A)), MatAdd(A), A)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [MatMul(4, A)])
+
+
+def test_cse_matrix_expression_matrix_solve():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ b = ImmutableDenseMatrix(symbols('b:2'))
+ x = MatrixSolve(A, b)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [x])
+
+
+def test_cse_matrix_matrix_expression():
+ X = ImmutableDenseMatrix(symbols('X:4')).reshape(2, 2)
+ y = ImmutableDenseMatrix(symbols('y:2'))
+ b = MatMul(Inverse(MatMul(Transpose(X), X)), Transpose(X), y)
+ cse_expr = cse(b)
+ x0 = MatrixSymbol('x0', 2, 2)
+ reduced_expr_expected = MatMul(Inverse(MatMul(x0, X)), x0, y)
+ assert cse_expr == ([(x0, Transpose(X))], [reduced_expr_expected])
+
+
+def test_cse_matrix_kalman_filter():
+ """Kalman Filter example from Matthew Rocklin's SciPy 2013 talk.
+
+ Talk titled: "Matrix Expressions and BLAS/LAPACK; SciPy 2013 Presentation"
+
+ Video: https://pyvideo.org/scipy-2013/matrix-expressions-and-blaslapack-scipy-2013-pr.html
+
+ Notes
+ =====
+
+ Equations are:
+
+ new_mu = mu + Sigma*H.T * (R + H*Sigma*H.T).I * (H*mu - data)
+ = MatAdd(mu, MatMul(Sigma, Transpose(H), Inverse(MatAdd(R, MatMul(H, Sigma, Transpose(H)))), MatAdd(MatMul(H, mu), MatMul(S.NegativeOne, data))))
+ new_Sigma = Sigma - Sigma*H.T * (R + H*Sigma*H.T).I * H * Sigma
+ = MatAdd(Sigma, MatMul(S.NegativeOne, Sigma, Transpose(H)), Inverse(MatAdd(R, MatMul(H*Sigma*Transpose(H)))), H, Sigma))
+
+ """
+ N = 2
+ mu = ImmutableDenseMatrix(symbols(f'mu:{N}'))
+ Sigma = ImmutableDenseMatrix(symbols(f'Sigma:{N * N}')).reshape(N, N)
+ H = ImmutableDenseMatrix(symbols(f'H:{N * N}')).reshape(N, N)
+ R = ImmutableDenseMatrix(symbols(f'R:{N * N}')).reshape(N, N)
+ data = ImmutableDenseMatrix(symbols(f'data:{N}'))
+ new_mu = MatAdd(mu, MatMul(Sigma, Transpose(H), Inverse(MatAdd(R, MatMul(H, Sigma, Transpose(H)))), MatAdd(MatMul(H, mu), MatMul(S.NegativeOne, data))))
+ new_Sigma = MatAdd(Sigma, MatMul(S.NegativeOne, Sigma, Transpose(H), Inverse(MatAdd(R, MatMul(H, Sigma, Transpose(H)))), H, Sigma))
+ cse_expr = cse([new_mu, new_Sigma])
+ x0 = MatrixSymbol('x0', N, N)
+ x1 = MatrixSymbol('x1', N, N)
+ replacements_expected = [
+ (x0, Transpose(H)),
+ (x1, Inverse(MatAdd(R, MatMul(H, Sigma, x0)))),
+ ]
+ reduced_exprs_expected = [
+ MatAdd(mu, MatMul(Sigma, x0, x1, MatAdd(MatMul(H, mu), MatMul(S.NegativeOne, data)))),
+ MatAdd(Sigma, MatMul(S.NegativeOne, Sigma, x0, x1, H, Sigma)),
+ ]
+ assert cse_expr == (replacements_expected, reduced_exprs_expected)
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_epathtools.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_epathtools.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8bb47b2f2ff624077ab9905677b181c587ab5a7
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_epathtools.py
@@ -0,0 +1,90 @@
+"""Tests for tools for manipulation of expressions using paths. """
+
+from sympy.simplify.epathtools import epath, EPath
+from sympy.testing.pytest import raises
+
+from sympy.core.numbers import E
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.abc import x, y, z, t
+
+
+def test_epath_select():
+ expr = [((x, 1, t), 2), ((3, y, 4), z)]
+
+ assert epath("/*", expr) == [((x, 1, t), 2), ((3, y, 4), z)]
+ assert epath("/*/*", expr) == [(x, 1, t), 2, (3, y, 4), z]
+ assert epath("/*/*/*", expr) == [x, 1, t, 3, y, 4]
+ assert epath("/*/*/*/*", expr) == []
+
+ assert epath("/[:]", expr) == [((x, 1, t), 2), ((3, y, 4), z)]
+ assert epath("/[:]/[:]", expr) == [(x, 1, t), 2, (3, y, 4), z]
+ assert epath("/[:]/[:]/[:]", expr) == [x, 1, t, 3, y, 4]
+ assert epath("/[:]/[:]/[:]/[:]", expr) == []
+
+ assert epath("/*/[:]", expr) == [(x, 1, t), 2, (3, y, 4), z]
+
+ assert epath("/*/[0]", expr) == [(x, 1, t), (3, y, 4)]
+ assert epath("/*/[1]", expr) == [2, z]
+ assert epath("/*/[2]", expr) == []
+
+ assert epath("/*/int", expr) == [2]
+ assert epath("/*/Symbol", expr) == [z]
+ assert epath("/*/tuple", expr) == [(x, 1, t), (3, y, 4)]
+ assert epath("/*/__iter__?", expr) == [(x, 1, t), (3, y, 4)]
+
+ assert epath("/*/int|tuple", expr) == [(x, 1, t), 2, (3, y, 4)]
+ assert epath("/*/Symbol|tuple", expr) == [(x, 1, t), (3, y, 4), z]
+ assert epath("/*/int|Symbol|tuple", expr) == [(x, 1, t), 2, (3, y, 4), z]
+
+ assert epath("/*/int|__iter__?", expr) == [(x, 1, t), 2, (3, y, 4)]
+ assert epath("/*/Symbol|__iter__?", expr) == [(x, 1, t), (3, y, 4), z]
+ assert epath(
+ "/*/int|Symbol|__iter__?", expr) == [(x, 1, t), 2, (3, y, 4), z]
+
+ assert epath("/*/[0]/int", expr) == [1, 3, 4]
+ assert epath("/*/[0]/Symbol", expr) == [x, t, y]
+
+ assert epath("/*/[0]/int[1:]", expr) == [1, 4]
+ assert epath("/*/[0]/Symbol[1:]", expr) == [t, y]
+
+ assert epath("/Symbol", x + y + z + 1) == [x, y, z]
+ assert epath("/*/*/Symbol", t + sin(x + 1) + cos(x + y + E)) == [x, x, y]
+
+
+def test_epath_apply():
+ expr = [((x, 1, t), 2), ((3, y, 4), z)]
+ func = lambda expr: expr**2
+
+ assert epath("/*", expr, list) == [[(x, 1, t), 2], [(3, y, 4), z]]
+
+ assert epath("/*/[0]", expr, list) == [([x, 1, t], 2), ([3, y, 4], z)]
+ assert epath("/*/[1]", expr, func) == [((x, 1, t), 4), ((3, y, 4), z**2)]
+ assert epath("/*/[2]", expr, list) == expr
+
+ assert epath("/*/[0]/int", expr, func) == [((x, 1, t), 2), ((9, y, 16), z)]
+ assert epath("/*/[0]/Symbol", expr, func) == [((x**2, 1, t**2), 2),
+ ((3, y**2, 4), z)]
+ assert epath(
+ "/*/[0]/int[1:]", expr, func) == [((x, 1, t), 2), ((3, y, 16), z)]
+ assert epath("/*/[0]/Symbol[1:]", expr, func) == [((x, 1, t**2),
+ 2), ((3, y**2, 4), z)]
+
+ assert epath("/Symbol", x + y + z + 1, func) == x**2 + y**2 + z**2 + 1
+ assert epath("/*/*/Symbol", t + sin(x + 1) + cos(x + y + E), func) == \
+ t + sin(x**2 + 1) + cos(x**2 + y**2 + E)
+
+
+def test_EPath():
+ assert EPath("/*/[0]")._path == "/*/[0]"
+ assert EPath(EPath("/*/[0]"))._path == "/*/[0]"
+ assert isinstance(epath("/*/[0]"), EPath) is True
+
+ assert repr(EPath("/*/[0]")) == "EPath('/*/[0]')"
+
+ raises(ValueError, lambda: EPath(""))
+ raises(ValueError, lambda: EPath("/"))
+ raises(ValueError, lambda: EPath("/|x"))
+ raises(ValueError, lambda: EPath("/["))
+ raises(ValueError, lambda: EPath("/[0]%"))
+
+ raises(NotImplementedError, lambda: EPath("Symbol"))
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_fu.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_fu.py
new file mode 100644
index 0000000000000000000000000000000000000000..2de2126b7333195fceeffe72dc9cb642e7eba9a9
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_fu.py
@@ -0,0 +1,492 @@
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.parameters import evaluate
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.elementary.hyperbolic import (cosh, coth, csch, sech, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, cot, csc, sec, sin, tan)
+from sympy.simplify.powsimp import powsimp
+from sympy.simplify.fu import (
+ L, TR1, TR10, TR10i, TR11, _TR11, TR12, TR12i, TR13, TR14, TR15, TR16,
+ TR111, TR2, TR2i, TR3, TR4, TR5, TR6, TR7, TR8, TR9, TRmorrie, _TR56 as T,
+ TRpower, hyper_as_trig, fu, process_common_addends, trig_split,
+ as_f_sign_1)
+from sympy.core.random import verify_numerically
+from sympy.abc import a, b, c, x, y, z
+
+
+def test_TR1():
+ assert TR1(2*csc(x) + sec(x)) == 1/cos(x) + 2/sin(x)
+
+
+def test_TR2():
+ assert TR2(tan(x)) == sin(x)/cos(x)
+ assert TR2(cot(x)) == cos(x)/sin(x)
+ assert TR2(tan(tan(x) - sin(x)/cos(x))) == 0
+
+
+def test_TR2i():
+ # just a reminder that ratios of powers only simplify if both
+ # numerator and denominator satisfy the condition that each
+ # has a positive base or an integer exponent; e.g. the following,
+ # at y=-1, x=1/2 gives sqrt(2)*I != -sqrt(2)*I
+ assert powsimp(2**x/y**x) != (2/y)**x
+
+ assert TR2i(sin(x)/cos(x)) == tan(x)
+ assert TR2i(sin(x)*sin(y)/cos(x)) == tan(x)*sin(y)
+ assert TR2i(1/(sin(x)/cos(x))) == 1/tan(x)
+ assert TR2i(1/(sin(x)*sin(y)/cos(x))) == 1/tan(x)/sin(y)
+ assert TR2i(sin(x)/2/(cos(x) + 1)) == sin(x)/(cos(x) + 1)/2
+
+ assert TR2i(sin(x)/2/(cos(x) + 1), half=True) == tan(x/2)/2
+ assert TR2i(sin(1)/(cos(1) + 1), half=True) == tan(S.Half)
+ assert TR2i(sin(2)/(cos(2) + 1), half=True) == tan(1)
+ assert TR2i(sin(4)/(cos(4) + 1), half=True) == tan(2)
+ assert TR2i(sin(5)/(cos(5) + 1), half=True) == tan(5*S.Half)
+ assert TR2i((cos(1) + 1)/sin(1), half=True) == 1/tan(S.Half)
+ assert TR2i((cos(2) + 1)/sin(2), half=True) == 1/tan(1)
+ assert TR2i((cos(4) + 1)/sin(4), half=True) == 1/tan(2)
+ assert TR2i((cos(5) + 1)/sin(5), half=True) == 1/tan(5*S.Half)
+ assert TR2i((cos(1) + 1)**(-a)*sin(1)**a, half=True) == tan(S.Half)**a
+ assert TR2i((cos(2) + 1)**(-a)*sin(2)**a, half=True) == tan(1)**a
+ assert TR2i((cos(4) + 1)**(-a)*sin(4)**a, half=True) == (cos(4) + 1)**(-a)*sin(4)**a
+ assert TR2i((cos(5) + 1)**(-a)*sin(5)**a, half=True) == (cos(5) + 1)**(-a)*sin(5)**a
+ assert TR2i((cos(1) + 1)**a*sin(1)**(-a), half=True) == tan(S.Half)**(-a)
+ assert TR2i((cos(2) + 1)**a*sin(2)**(-a), half=True) == tan(1)**(-a)
+ assert TR2i((cos(4) + 1)**a*sin(4)**(-a), half=True) == (cos(4) + 1)**a*sin(4)**(-a)
+ assert TR2i((cos(5) + 1)**a*sin(5)**(-a), half=True) == (cos(5) + 1)**a*sin(5)**(-a)
+
+ i = symbols('i', integer=True)
+ assert TR2i(((cos(5) + 1)**i*sin(5)**(-i)), half=True) == tan(5*S.Half)**(-i)
+ assert TR2i(1/((cos(5) + 1)**i*sin(5)**(-i)), half=True) == tan(5*S.Half)**i
+
+
+def test_TR3():
+ assert TR3(cos(y - x*(y - x))) == cos(x*(x - y) + y)
+ assert cos(pi/2 + x) == -sin(x)
+ assert cos(30*pi/2 + x) == -cos(x)
+
+ for f in (cos, sin, tan, cot, csc, sec):
+ i = f(pi*Rational(3, 7))
+ j = TR3(i)
+ assert verify_numerically(i, j) and i.func != j.func
+
+ with evaluate(False):
+ eq = cos(9*pi/22)
+ assert eq.has(9*pi) and TR3(eq) == sin(pi/11)
+
+
+def test_TR4():
+ for i in [0, pi/6, pi/4, pi/3, pi/2]:
+ with evaluate(False):
+ eq = cos(i)
+ assert isinstance(eq, cos) and TR4(eq) == cos(i)
+
+
+def test__TR56():
+ h = lambda x: 1 - x
+ assert T(sin(x)**3, sin, cos, h, 4, False) == sin(x)*(-cos(x)**2 + 1)
+ assert T(sin(x)**10, sin, cos, h, 4, False) == sin(x)**10
+ assert T(sin(x)**6, sin, cos, h, 6, False) == (-cos(x)**2 + 1)**3
+ assert T(sin(x)**6, sin, cos, h, 6, True) == sin(x)**6
+ assert T(sin(x)**8, sin, cos, h, 10, True) == (-cos(x)**2 + 1)**4
+
+ # issue 17137
+ assert T(sin(x)**I, sin, cos, h, 4, True) == sin(x)**I
+ assert T(sin(x)**(2*I + 1), sin, cos, h, 4, True) == sin(x)**(2*I + 1)
+
+
+def test_TR5():
+ assert TR5(sin(x)**2) == -cos(x)**2 + 1
+ assert TR5(sin(x)**-2) == sin(x)**(-2)
+ assert TR5(sin(x)**4) == (-cos(x)**2 + 1)**2
+
+
+def test_TR6():
+ assert TR6(cos(x)**2) == -sin(x)**2 + 1
+ assert TR6(cos(x)**-2) == cos(x)**(-2)
+ assert TR6(cos(x)**4) == (-sin(x)**2 + 1)**2
+
+
+def test_TR7():
+ assert TR7(cos(x)**2) == cos(2*x)/2 + S.Half
+ assert TR7(cos(x)**2 + 1) == cos(2*x)/2 + Rational(3, 2)
+
+
+def test_TR8():
+ assert TR8(cos(2)*cos(3)) == cos(5)/2 + cos(1)/2
+ assert TR8(cos(2)*sin(3)) == sin(5)/2 + sin(1)/2
+ assert TR8(sin(2)*sin(3)) == -cos(5)/2 + cos(1)/2
+ assert TR8(sin(1)*sin(2)*sin(3)) == sin(4)/4 - sin(6)/4 + sin(2)/4
+ assert TR8(cos(2)*cos(3)*cos(4)*cos(5)) == \
+ cos(4)/4 + cos(10)/8 + cos(2)/8 + cos(8)/8 + cos(14)/8 + \
+ cos(6)/8 + Rational(1, 8)
+ assert TR8(cos(2)*cos(3)*cos(4)*cos(5)*cos(6)) == \
+ cos(10)/8 + cos(4)/8 + 3*cos(2)/16 + cos(16)/16 + cos(8)/8 + \
+ cos(14)/16 + cos(20)/16 + cos(12)/16 + Rational(1, 16) + cos(6)/8
+ assert TR8(sin(pi*Rational(3, 7))**2*cos(pi*Rational(3, 7))**2/(16*sin(pi/7)**2)) == Rational(1, 64)
+
+def test_TR9():
+ a = S.Half
+ b = 3*a
+ assert TR9(a) == a
+ assert TR9(cos(1) + cos(2)) == 2*cos(a)*cos(b)
+ assert TR9(cos(1) - cos(2)) == 2*sin(a)*sin(b)
+ assert TR9(sin(1) - sin(2)) == -2*sin(a)*cos(b)
+ assert TR9(sin(1) + sin(2)) == 2*sin(b)*cos(a)
+ assert TR9(cos(1) + 2*sin(1) + 2*sin(2)) == cos(1) + 4*sin(b)*cos(a)
+ assert TR9(cos(4) + cos(2) + 2*cos(1)*cos(3)) == 4*cos(1)*cos(3)
+ assert TR9((cos(4) + cos(2))/cos(3)/2 + cos(3)) == 2*cos(1)*cos(2)
+ assert TR9(cos(3) + cos(4) + cos(5) + cos(6)) == \
+ 4*cos(S.Half)*cos(1)*cos(Rational(9, 2))
+ assert TR9(cos(3) + cos(3)*cos(2)) == cos(3) + cos(2)*cos(3)
+ assert TR9(-cos(y) + cos(x*y)) == -2*sin(x*y/2 - y/2)*sin(x*y/2 + y/2)
+ assert TR9(-sin(y) + sin(x*y)) == 2*sin(x*y/2 - y/2)*cos(x*y/2 + y/2)
+ c = cos(x)
+ s = sin(x)
+ for si in ((1, 1), (1, -1), (-1, 1), (-1, -1)):
+ for a in ((c, s), (s, c), (cos(x), cos(x*y)), (sin(x), sin(x*y))):
+ args = zip(si, a)
+ ex = Add(*[Mul(*ai) for ai in args])
+ t = TR9(ex)
+ assert not (a[0].func == a[1].func and (
+ not verify_numerically(ex, t.expand(trig=True)) or t.is_Add)
+ or a[1].func != a[0].func and ex != t)
+
+
+def test_TR10():
+ assert TR10(cos(a + b)) == -sin(a)*sin(b) + cos(a)*cos(b)
+ assert TR10(sin(a + b)) == sin(a)*cos(b) + sin(b)*cos(a)
+ assert TR10(sin(a + b + c)) == \
+ (-sin(a)*sin(b) + cos(a)*cos(b))*sin(c) + \
+ (sin(a)*cos(b) + sin(b)*cos(a))*cos(c)
+ assert TR10(cos(a + b + c)) == \
+ (-sin(a)*sin(b) + cos(a)*cos(b))*cos(c) - \
+ (sin(a)*cos(b) + sin(b)*cos(a))*sin(c)
+
+
+def test_TR10i():
+ assert TR10i(cos(1)*cos(3) + sin(1)*sin(3)) == cos(2)
+ assert TR10i(cos(1)*cos(3) - sin(1)*sin(3)) == cos(4)
+ assert TR10i(cos(1)*sin(3) - sin(1)*cos(3)) == sin(2)
+ assert TR10i(cos(1)*sin(3) + sin(1)*cos(3)) == sin(4)
+ assert TR10i(cos(1)*sin(3) + sin(1)*cos(3) + 7) == sin(4) + 7
+ assert TR10i(cos(1)*sin(3) + sin(1)*cos(3) + cos(3)) == cos(3) + sin(4)
+ assert TR10i(2*cos(1)*sin(3) + 2*sin(1)*cos(3) + cos(3)) == \
+ 2*sin(4) + cos(3)
+ assert TR10i(cos(2)*cos(3) + sin(2)*(cos(1)*sin(2) + cos(2)*sin(1))) == \
+ cos(1)
+ eq = (cos(2)*cos(3) + sin(2)*(
+ cos(1)*sin(2) + cos(2)*sin(1)))*cos(5) + sin(1)*sin(5)
+ assert TR10i(eq) == TR10i(eq.expand()) == cos(4)
+ assert TR10i(sqrt(2)*cos(x)*x + sqrt(6)*sin(x)*x) == \
+ 2*sqrt(2)*x*sin(x + pi/6)
+ assert TR10i(cos(x)/sqrt(6) + sin(x)/sqrt(2) +
+ cos(x)/sqrt(6)/3 + sin(x)/sqrt(2)/3) == 4*sqrt(6)*sin(x + pi/6)/9
+ assert TR10i(cos(x)/sqrt(6) + sin(x)/sqrt(2) +
+ cos(y)/sqrt(6)/3 + sin(y)/sqrt(2)/3) == \
+ sqrt(6)*sin(x + pi/6)/3 + sqrt(6)*sin(y + pi/6)/9
+ assert TR10i(cos(x) + sqrt(3)*sin(x) + 2*sqrt(3)*cos(x + pi/6)) == 4*cos(x)
+ assert TR10i(cos(x) + sqrt(3)*sin(x) +
+ 2*sqrt(3)*cos(x + pi/6) + 4*sin(x)) == 4*sqrt(2)*sin(x + pi/4)
+ assert TR10i(cos(2)*sin(3) + sin(2)*cos(4)) == \
+ sin(2)*cos(4) + sin(3)*cos(2)
+
+ A = Symbol('A', commutative=False)
+ assert TR10i(sqrt(2)*cos(x)*A + sqrt(6)*sin(x)*A) == \
+ 2*sqrt(2)*sin(x + pi/6)*A
+
+
+ c = cos(x)
+ s = sin(x)
+ h = sin(y)
+ r = cos(y)
+ for si in ((1, 1), (1, -1), (-1, 1), (-1, -1)):
+ for argsi in ((c*r, s*h), (c*h, s*r)): # explicit 2-args
+ args = zip(si, argsi)
+ ex = Add(*[Mul(*ai) for ai in args])
+ t = TR10i(ex)
+ assert not (ex - t.expand(trig=True) or t.is_Add)
+
+ c = cos(x)
+ s = sin(x)
+ h = sin(pi/6)
+ r = cos(pi/6)
+ for si in ((1, 1), (1, -1), (-1, 1), (-1, -1)):
+ for argsi in ((c*r, s*h), (c*h, s*r)): # induced
+ args = zip(si, argsi)
+ ex = Add(*[Mul(*ai) for ai in args])
+ t = TR10i(ex)
+ assert not (ex - t.expand(trig=True) or t.is_Add)
+
+
+def test_TR11():
+
+ assert TR11(sin(2*x)) == 2*sin(x)*cos(x)
+ assert TR11(sin(4*x)) == 4*((-sin(x)**2 + cos(x)**2)*sin(x)*cos(x))
+ assert TR11(sin(x*Rational(4, 3))) == \
+ 4*((-sin(x/3)**2 + cos(x/3)**2)*sin(x/3)*cos(x/3))
+
+ assert TR11(cos(2*x)) == -sin(x)**2 + cos(x)**2
+ assert TR11(cos(4*x)) == \
+ (-sin(x)**2 + cos(x)**2)**2 - 4*sin(x)**2*cos(x)**2
+
+ assert TR11(cos(2)) == cos(2)
+
+ assert TR11(cos(pi*Rational(3, 7)), pi*Rational(2, 7)) == -cos(pi*Rational(2, 7))**2 + sin(pi*Rational(2, 7))**2
+ assert TR11(cos(4), 2) == -sin(2)**2 + cos(2)**2
+ assert TR11(cos(6), 2) == cos(6)
+ assert TR11(sin(x)/cos(x/2), x/2) == 2*sin(x/2)
+
+def test__TR11():
+
+ assert _TR11(sin(x/3)*sin(2*x)*sin(x/4)/(cos(x/6)*cos(x/8))) == \
+ 4*sin(x/8)*sin(x/6)*sin(2*x),_TR11(sin(x/3)*sin(2*x)*sin(x/4)/(cos(x/6)*cos(x/8)))
+ assert _TR11(sin(x/3)/cos(x/6)) == 2*sin(x/6)
+
+ assert _TR11(cos(x/6)/sin(x/3)) == 1/(2*sin(x/6))
+ assert _TR11(sin(2*x)*cos(x/8)/sin(x/4)) == sin(2*x)/(2*sin(x/8)), _TR11(sin(2*x)*cos(x/8)/sin(x/4))
+ assert _TR11(sin(x)/sin(x/2)) == 2*cos(x/2)
+
+
+def test_TR12():
+ assert TR12(tan(x + y)) == (tan(x) + tan(y))/(-tan(x)*tan(y) + 1)
+ assert TR12(tan(x + y + z)) ==\
+ (tan(z) + (tan(x) + tan(y))/(-tan(x)*tan(y) + 1))/(
+ 1 - (tan(x) + tan(y))*tan(z)/(-tan(x)*tan(y) + 1))
+ assert TR12(tan(x*y)) == tan(x*y)
+
+
+def test_TR13():
+ assert TR13(tan(3)*tan(2)) == -tan(2)/tan(5) - tan(3)/tan(5) + 1
+ assert TR13(cot(3)*cot(2)) == 1 + cot(3)*cot(5) + cot(2)*cot(5)
+ assert TR13(tan(1)*tan(2)*tan(3)) == \
+ (-tan(2)/tan(5) - tan(3)/tan(5) + 1)*tan(1)
+ assert TR13(tan(1)*tan(2)*cot(3)) == \
+ (-tan(2)/tan(3) + 1 - tan(1)/tan(3))*cot(3)
+
+
+def test_L():
+ assert L(cos(x) + sin(x)) == 2
+
+
+def test_fu():
+
+ assert fu(sin(50)**2 + cos(50)**2 + sin(pi/6)) == Rational(3, 2)
+ assert fu(sqrt(6)*cos(x) + sqrt(2)*sin(x)) == 2*sqrt(2)*sin(x + pi/3)
+
+
+ eq = sin(x)**4 - cos(y)**2 + sin(y)**2 + 2*cos(x)**2
+ assert fu(eq) == cos(x)**4 - 2*cos(y)**2 + 2
+
+ assert fu(S.Half - cos(2*x)/2) == sin(x)**2
+
+ assert fu(sin(a)*(cos(b) - sin(b)) + cos(a)*(sin(b) + cos(b))) == \
+ sqrt(2)*sin(a + b + pi/4)
+
+ assert fu(sqrt(3)*cos(x)/2 + sin(x)/2) == sin(x + pi/3)
+
+ assert fu(1 - sin(2*x)**2/4 - sin(y)**2 - cos(x)**4) == \
+ -cos(x)**2 + cos(y)**2
+
+ assert fu(cos(pi*Rational(4, 9))) == sin(pi/18)
+ assert fu(cos(pi/9)*cos(pi*Rational(2, 9))*cos(pi*Rational(3, 9))*cos(pi*Rational(4, 9))) == Rational(1, 16)
+
+ assert fu(
+ tan(pi*Rational(7, 18)) + tan(pi*Rational(5, 18)) - sqrt(3)*tan(pi*Rational(5, 18))*tan(pi*Rational(7, 18))) == \
+ -sqrt(3)
+
+ assert fu(tan(1)*tan(2)) == tan(1)*tan(2)
+
+ expr = Mul(*[cos(2**i) for i in range(10)])
+ assert fu(expr) == sin(1024)/(1024*sin(1))
+
+ # issue #18059:
+ assert fu(cos(x) + sqrt(sin(x)**2)) == cos(x) + sqrt(sin(x)**2)
+
+ assert fu((-14*sin(x)**3 + 35*sin(x) + 6*sqrt(3)*cos(x)**3 + 9*sqrt(3)*cos(x))/((cos(2*x) + 4))) == \
+ 7*sin(x) + 3*sqrt(3)*cos(x)
+
+
+def test_objective():
+ assert fu(sin(x)/cos(x), measure=lambda x: x.count_ops()) == \
+ tan(x)
+ assert fu(sin(x)/cos(x), measure=lambda x: -x.count_ops()) == \
+ sin(x)/cos(x)
+
+
+def test_process_common_addends():
+ # this tests that the args are not evaluated as they are given to do
+ # and that key2 works when key1 is False
+ do = lambda x: Add(*[i**(i%2) for i in x.args])
+ assert process_common_addends(Add(*[1, 2, 3, 4], evaluate=False), do,
+ key2=lambda x: x%2, key1=False) == 1**1 + 3**1 + 2**0 + 4**0
+
+
+def test_trig_split():
+ assert trig_split(cos(x), cos(y)) == (1, 1, 1, x, y, True)
+ assert trig_split(2*cos(x), -2*cos(y)) == (2, 1, -1, x, y, True)
+ assert trig_split(cos(x)*sin(y), cos(y)*sin(y)) == \
+ (sin(y), 1, 1, x, y, True)
+
+ assert trig_split(cos(x), -sqrt(3)*sin(x), two=True) == \
+ (2, 1, -1, x, pi/6, False)
+ assert trig_split(cos(x), sin(x), two=True) == \
+ (sqrt(2), 1, 1, x, pi/4, False)
+ assert trig_split(cos(x), -sin(x), two=True) == \
+ (sqrt(2), 1, -1, x, pi/4, False)
+ assert trig_split(sqrt(2)*cos(x), -sqrt(6)*sin(x), two=True) == \
+ (2*sqrt(2), 1, -1, x, pi/6, False)
+ assert trig_split(-sqrt(6)*cos(x), -sqrt(2)*sin(x), two=True) == \
+ (-2*sqrt(2), 1, 1, x, pi/3, False)
+ assert trig_split(cos(x)/sqrt(6), sin(x)/sqrt(2), two=True) == \
+ (sqrt(6)/3, 1, 1, x, pi/6, False)
+ assert trig_split(-sqrt(6)*cos(x)*sin(y),
+ -sqrt(2)*sin(x)*sin(y), two=True) == \
+ (-2*sqrt(2)*sin(y), 1, 1, x, pi/3, False)
+
+ assert trig_split(cos(x), sin(x)) is None
+ assert trig_split(cos(x), sin(z)) is None
+ assert trig_split(2*cos(x), -sin(x)) is None
+ assert trig_split(cos(x), -sqrt(3)*sin(x)) is None
+ assert trig_split(cos(x)*cos(y), sin(x)*sin(z)) is None
+ assert trig_split(cos(x)*cos(y), sin(x)*sin(y)) is None
+ assert trig_split(-sqrt(6)*cos(x), sqrt(2)*sin(x)*sin(y), two=True) is \
+ None
+
+ assert trig_split(sqrt(3)*sqrt(x), cos(3), two=True) is None
+ assert trig_split(sqrt(3)*root(x, 3), sin(3)*cos(2), two=True) is None
+ assert trig_split(cos(5)*cos(6), cos(7)*sin(5), two=True) is None
+
+
+def test_TRmorrie():
+ assert TRmorrie(7*Mul(*[cos(i) for i in range(10)])) == \
+ 7*sin(12)*sin(16)*cos(5)*cos(7)*cos(9)/(64*sin(1)*sin(3))
+ assert TRmorrie(x) == x
+ assert TRmorrie(2*x) == 2*x
+ e = cos(pi/7)*cos(pi*Rational(2, 7))*cos(pi*Rational(4, 7))
+ assert TR8(TRmorrie(e)) == Rational(-1, 8)
+ e = Mul(*[cos(2**i*pi/17) for i in range(1, 17)])
+ assert TR8(TR3(TRmorrie(e))) == Rational(1, 65536)
+ # issue 17063
+ eq = cos(x)/cos(x/2)
+ assert TRmorrie(eq) == eq
+ # issue #20430
+ eq = cos(x/2)*sin(x/2)*cos(x)**3
+ assert TRmorrie(eq) == sin(2*x)*cos(x)**2/4
+
+
+def test_TRpower():
+ assert TRpower(1/sin(x)**2) == 1/sin(x)**2
+ assert TRpower(cos(x)**3*sin(x/2)**4) == \
+ (3*cos(x)/4 + cos(3*x)/4)*(-cos(x)/2 + cos(2*x)/8 + Rational(3, 8))
+ for k in range(2, 8):
+ assert verify_numerically(sin(x)**k, TRpower(sin(x)**k))
+ assert verify_numerically(cos(x)**k, TRpower(cos(x)**k))
+
+
+def test_hyper_as_trig():
+ from sympy.simplify.fu import _osborne, _osbornei
+
+ eq = sinh(x)**2 + cosh(x)**2
+ t, f = hyper_as_trig(eq)
+ assert f(fu(t)) == cosh(2*x)
+ e, f = hyper_as_trig(tanh(x + y))
+ assert f(TR12(e)) == (tanh(x) + tanh(y))/(tanh(x)*tanh(y) + 1)
+
+ d = Dummy()
+ assert _osborne(sinh(x), d) == I*sin(x*d)
+ assert _osborne(tanh(x), d) == I*tan(x*d)
+ assert _osborne(coth(x), d) == cot(x*d)/I
+ assert _osborne(cosh(x), d) == cos(x*d)
+ assert _osborne(sech(x), d) == sec(x*d)
+ assert _osborne(csch(x), d) == csc(x*d)/I
+ for func in (sinh, cosh, tanh, coth, sech, csch):
+ h = func(pi)
+ assert _osbornei(_osborne(h, d), d) == h
+ # /!\ the _osborne functions are not meant to work
+ # in the o(i(trig, d), d) direction so we just check
+ # that they work as they are supposed to work
+ assert _osbornei(cos(x*y + z), y) == cosh(x + z*I)
+ assert _osbornei(sin(x*y + z), y) == sinh(x + z*I)/I
+ assert _osbornei(tan(x*y + z), y) == tanh(x + z*I)/I
+ assert _osbornei(cot(x*y + z), y) == coth(x + z*I)*I
+ assert _osbornei(sec(x*y + z), y) == sech(x + z*I)
+ assert _osbornei(csc(x*y + z), y) == csch(x + z*I)*I
+
+
+def test_TR12i():
+ ta, tb, tc = [tan(i) for i in (a, b, c)]
+ assert TR12i((ta + tb)/(-ta*tb + 1)) == tan(a + b)
+ assert TR12i((ta + tb)/(ta*tb - 1)) == -tan(a + b)
+ assert TR12i((-ta - tb)/(ta*tb - 1)) == tan(a + b)
+ eq = (ta + tb)/(-ta*tb + 1)**2*(-3*ta - 3*tc)/(2*(ta*tc - 1))
+ assert TR12i(eq.expand()) == \
+ -3*tan(a + b)*tan(a + c)/(tan(a) + tan(b) - 1)/2
+ assert TR12i(tan(x)/sin(x)) == tan(x)/sin(x)
+ eq = (ta + cos(2))/(-ta*tb + 1)
+ assert TR12i(eq) == eq
+ eq = (ta + tb + 2)**2/(-ta*tb + 1)
+ assert TR12i(eq) == eq
+ eq = ta/(-ta*tb + 1)
+ assert TR12i(eq) == eq
+ eq = (((ta + tb)*(a + 1)).expand())**2/(ta*tb - 1)
+ assert TR12i(eq) == -(a + 1)**2*tan(a + b)
+
+
+def test_TR14():
+ eq = (cos(x) - 1)*(cos(x) + 1)
+ ans = -sin(x)**2
+ assert TR14(eq) == ans
+ assert TR14(1/eq) == 1/ans
+ assert TR14((cos(x) - 1)**2*(cos(x) + 1)**2) == ans**2
+ assert TR14((cos(x) - 1)**2*(cos(x) + 1)**3) == ans**2*(cos(x) + 1)
+ assert TR14((cos(x) - 1)**3*(cos(x) + 1)**2) == ans**2*(cos(x) - 1)
+ eq = (cos(x) - 1)**y*(cos(x) + 1)**y
+ assert TR14(eq) == eq
+ eq = (cos(x) - 2)**y*(cos(x) + 1)
+ assert TR14(eq) == eq
+ eq = (tan(x) - 2)**2*(cos(x) + 1)
+ assert TR14(eq) == eq
+ i = symbols('i', integer=True)
+ assert TR14((cos(x) - 1)**i*(cos(x) + 1)**i) == ans**i
+ assert TR14((sin(x) - 1)**i*(sin(x) + 1)**i) == (-cos(x)**2)**i
+ # could use extraction in this case
+ eq = (cos(x) - 1)**(i + 1)*(cos(x) + 1)**i
+ assert TR14(eq) in [(cos(x) - 1)*ans**i, eq]
+
+ assert TR14((sin(x) - 1)*(sin(x) + 1)) == -cos(x)**2
+ p1 = (cos(x) + 1)*(cos(x) - 1)
+ p2 = (cos(y) - 1)*2*(cos(y) + 1)
+ p3 = (3*(cos(y) - 1))*(3*(cos(y) + 1))
+ assert TR14(p1*p2*p3*(x - 1)) == -18*((x - 1)*sin(x)**2*sin(y)**4)
+
+
+def test_TR15_16_17():
+ assert TR15(1 - 1/sin(x)**2) == -cot(x)**2
+ assert TR16(1 - 1/cos(x)**2) == -tan(x)**2
+ assert TR111(1 - 1/tan(x)**2) == 1 - cot(x)**2
+
+
+def test_as_f_sign_1():
+ assert as_f_sign_1(x + 1) == (1, x, 1)
+ assert as_f_sign_1(x - 1) == (1, x, -1)
+ assert as_f_sign_1(-x + 1) == (-1, x, -1)
+ assert as_f_sign_1(-x - 1) == (-1, x, 1)
+ assert as_f_sign_1(2*x + 2) == (2, x, 1)
+ assert as_f_sign_1(x*y - y) == (y, x, -1)
+ assert as_f_sign_1(-x*y + y) == (-y, x, -1)
+
+
+def test_issue_25590():
+ A = Symbol('A', commutative=False)
+ B = Symbol('B', commutative=False)
+
+ assert TR8(2*cos(x)*sin(x)*B*A) == sin(2*x)*B*A
+ assert TR13(tan(2)*tan(3)*B*A) == (-tan(2)/tan(5) - tan(3)/tan(5) + 1)*B*A
+
+ # XXX The result may not be optimal than
+ # sin(2*x)*B*A + cos(x)**2 and may change in the future
+ assert (2*cos(x)*sin(x)*B*A + cos(x)**2).simplify() == sin(2*x)*B*A + cos(2*x)/2 + S.One/2
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_function.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_function.py
new file mode 100644
index 0000000000000000000000000000000000000000..441b9faf1bb3c5e7f2279b2a61066d050e45f773
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_function.py
@@ -0,0 +1,54 @@
+""" Unit tests for Hyper_Function"""
+from sympy.core import symbols, Dummy, Tuple, S, Rational
+from sympy.functions import hyper
+
+from sympy.simplify.hyperexpand import Hyper_Function
+
+def test_attrs():
+ a, b = symbols('a, b', cls=Dummy)
+ f = Hyper_Function([2, a], [b])
+ assert f.ap == Tuple(2, a)
+ assert f.bq == Tuple(b)
+ assert f.args == (Tuple(2, a), Tuple(b))
+ assert f.sizes == (2, 1)
+
+def test_call():
+ a, b, x = symbols('a, b, x', cls=Dummy)
+ f = Hyper_Function([2, a], [b])
+ assert f(x) == hyper([2, a], [b], x)
+
+def test_has():
+ a, b, c = symbols('a, b, c', cls=Dummy)
+ f = Hyper_Function([2, -a], [b])
+ assert f.has(a)
+ assert f.has(Tuple(b))
+ assert not f.has(c)
+
+def test_eq():
+ assert Hyper_Function([1], []) == Hyper_Function([1], [])
+ assert (Hyper_Function([1], []) != Hyper_Function([1], [])) is False
+ assert Hyper_Function([1], []) != Hyper_Function([2], [])
+ assert Hyper_Function([1], []) != Hyper_Function([1, 2], [])
+ assert Hyper_Function([1], []) != Hyper_Function([1], [2])
+
+def test_gamma():
+ assert Hyper_Function([2, 3], [-1]).gamma == 0
+ assert Hyper_Function([-2, -3], [-1]).gamma == 2
+ n = Dummy(integer=True)
+ assert Hyper_Function([-1, n, 1], []).gamma == 1
+ assert Hyper_Function([-1, -n, 1], []).gamma == 1
+ p = Dummy(integer=True, positive=True)
+ assert Hyper_Function([-1, p, 1], []).gamma == 1
+ assert Hyper_Function([-1, -p, 1], []).gamma == 2
+
+def test_suitable_origin():
+ assert Hyper_Function((S.Half,), (Rational(3, 2),))._is_suitable_origin() is True
+ assert Hyper_Function((S.Half,), (S.Half,))._is_suitable_origin() is False
+ assert Hyper_Function((S.Half,), (Rational(-1, 2),))._is_suitable_origin() is False
+ assert Hyper_Function((S.Half,), (0,))._is_suitable_origin() is False
+ assert Hyper_Function((S.Half,), (-1, 1,))._is_suitable_origin() is False
+ assert Hyper_Function((S.Half, 0), (1,))._is_suitable_origin() is False
+ assert Hyper_Function((S.Half, 1),
+ (2, Rational(-2, 3)))._is_suitable_origin() is True
+ assert Hyper_Function((S.Half, 1),
+ (2, Rational(-2, 3), Rational(3, 2)))._is_suitable_origin() is True
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_gammasimp.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_gammasimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4c73093250b279510e3c2274db22818a9adffd8
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_gammasimp.py
@@ -0,0 +1,127 @@
+from sympy.core.function import Function
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import (rf, binomial, factorial)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.simplify.gammasimp import gammasimp
+from sympy.simplify.powsimp import powsimp
+from sympy.simplify.simplify import simplify
+
+from sympy.abc import x, y, n, k
+
+
+def test_gammasimp():
+ R = Rational
+
+ # was part of test_combsimp_gamma() in test_combsimp.py
+ assert gammasimp(gamma(x)) == gamma(x)
+ assert gammasimp(gamma(x + 1)/x) == gamma(x)
+ assert gammasimp(gamma(x)/(x - 1)) == gamma(x - 1)
+ assert gammasimp(x*gamma(x)) == gamma(x + 1)
+ assert gammasimp((x + 1)*gamma(x + 1)) == gamma(x + 2)
+ assert gammasimp(gamma(x + y)*(x + y)) == gamma(x + y + 1)
+ assert gammasimp(x/gamma(x + 1)) == 1/gamma(x)
+ assert gammasimp((x + 1)**2/gamma(x + 2)) == (x + 1)/gamma(x + 1)
+ assert gammasimp(x*gamma(x) + gamma(x + 3)/(x + 2)) == \
+ (x + 2)*gamma(x + 1)
+
+ assert gammasimp(gamma(2*x)*x) == gamma(2*x + 1)/2
+ assert gammasimp(gamma(2*x)/(x - S.Half)) == 2*gamma(2*x - 1)
+
+ assert gammasimp(gamma(x)*gamma(1 - x)) == pi/sin(pi*x)
+ assert gammasimp(gamma(x)*gamma(-x)) == -pi/(x*sin(pi*x))
+ assert gammasimp(1/gamma(x + 3)/gamma(1 - x)) == \
+ sin(pi*x)/(pi*x*(x + 1)*(x + 2))
+
+ assert gammasimp(factorial(n + 2)) == gamma(n + 3)
+ assert gammasimp(binomial(n, k)) == \
+ gamma(n + 1)/(gamma(k + 1)*gamma(-k + n + 1))
+
+ assert powsimp(gammasimp(
+ gamma(x)*gamma(x + S.Half)*gamma(y)/gamma(x + y))) == \
+ 2**(-2*x + 1)*sqrt(pi)*gamma(2*x)*gamma(y)/gamma(x + y)
+ assert gammasimp(1/gamma(x)/gamma(x - Rational(1, 3))/gamma(x + Rational(1, 3))) == \
+ 3**(3*x - Rational(3, 2))/(2*pi*gamma(3*x - 1))
+ assert simplify(
+ gamma(S.Half + x/2)*gamma(1 + x/2)/gamma(1 + x)/sqrt(pi)*2**x) == 1
+ assert gammasimp(gamma(Rational(-1, 4))*gamma(Rational(-3, 4))) == 16*sqrt(2)*pi/3
+
+ assert powsimp(gammasimp(gamma(2*x)/gamma(x))) == \
+ 2**(2*x - 1)*gamma(x + S.Half)/sqrt(pi)
+
+ # issue 6792
+ e = (-gamma(k)*gamma(k + 2) + gamma(k + 1)**2)/gamma(k)**2
+ assert gammasimp(e) == -k
+ assert gammasimp(1/e) == -1/k
+ e = (gamma(x) + gamma(x + 1))/gamma(x)
+ assert gammasimp(e) == x + 1
+ assert gammasimp(1/e) == 1/(x + 1)
+ e = (gamma(x) + gamma(x + 2))*(gamma(x - 1) + gamma(x))/gamma(x)
+ assert gammasimp(e) == (x**2 + x + 1)*gamma(x + 1)/(x - 1)
+ e = (-gamma(k)*gamma(k + 2) + gamma(k + 1)**2)/gamma(k)**2
+ assert gammasimp(e**2) == k**2
+ assert gammasimp(e**2/gamma(k + 1)) == k/gamma(k)
+ a = R(1, 2) + R(1, 3)
+ b = a + R(1, 3)
+ assert gammasimp(gamma(2*k)/gamma(k)*gamma(k + a)*gamma(k + b)
+ ) == 3*2**(2*k + 1)*3**(-3*k - 2)*sqrt(pi)*gamma(3*k + R(3, 2))/2
+
+ # issue 9699
+ assert gammasimp((x + 1)*factorial(x)/gamma(y)) == gamma(x + 2)/gamma(y)
+ assert gammasimp(rf(x + n, k)*binomial(n, k)).simplify() == Piecewise(
+ (gamma(n + 1)*gamma(k + n + x)/(gamma(k + 1)*gamma(n + x)*gamma(-k + n + 1)), n > -x),
+ ((-1)**k*gamma(n + 1)*gamma(-n - x + 1)/(gamma(k + 1)*gamma(-k + n + 1)*gamma(-k - n - x + 1)), True))
+
+ A, B = symbols('A B', commutative=False)
+ assert gammasimp(e*B*A) == gammasimp(e)*B*A
+
+ # check iteration
+ assert gammasimp(gamma(2*k)/gamma(k)*gamma(-k - R(1, 2))) == (
+ -2**(2*k + 1)*sqrt(pi)/(2*((2*k + 1)*cos(pi*k))))
+ assert gammasimp(
+ gamma(k)*gamma(k + R(1, 3))*gamma(k + R(2, 3))/gamma(k*R(3, 2))) == (
+ 3*2**(3*k + 1)*3**(-3*k - S.Half)*sqrt(pi)*gamma(k*R(3, 2) + S.Half)/2)
+
+ # issue 6153
+ assert gammasimp(gamma(Rational(1, 4))/gamma(Rational(5, 4))) == 4
+
+ # was part of test_combsimp() in test_combsimp.py
+ assert gammasimp(binomial(n + 2, k + S.Half)) == gamma(n + 3)/ \
+ (gamma(k + R(3, 2))*gamma(-k + n + R(5, 2)))
+ assert gammasimp(binomial(n + 2, k + 2.0)) == \
+ gamma(n + 3)/(gamma(k + 3.0)*gamma(-k + n + 1))
+
+ # issue 11548
+ assert gammasimp(binomial(0, x)) == sin(pi*x)/(pi*x)
+
+ e = gamma(n + Rational(1, 3))*gamma(n + R(2, 3))
+ assert gammasimp(e) == e
+ assert gammasimp(gamma(4*n + S.Half)/gamma(2*n - R(3, 4))) == \
+ 2**(4*n - R(5, 2))*(8*n - 3)*gamma(2*n + R(3, 4))/sqrt(pi)
+
+ i, m = symbols('i m', integer = True)
+ e = gamma(exp(i))
+ assert gammasimp(e) == e
+ e = gamma(m + 3)
+ assert gammasimp(e) == e
+ e = gamma(m + 1)/(gamma(i + 1)*gamma(-i + m + 1))
+ assert gammasimp(e) == e
+
+ p = symbols("p", integer=True, positive=True)
+ assert gammasimp(gamma(-p + 4)) == gamma(-p + 4)
+
+
+def test_issue_22606():
+ fx = Function('f')(x)
+ eq = x + gamma(y)
+ # seems like ans should be `eq`, not `(x*y + gamma(y + 1))/y`
+ ans = gammasimp(eq)
+ assert gammasimp(eq.subs(x, fx)).subs(fx, x) == ans
+ assert gammasimp(eq.subs(x, cos(x))).subs(cos(x), x) == ans
+ assert 1/gammasimp(1/eq) == ans
+ assert gammasimp(fx.subs(x, eq)).args[0] == ans
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_hyperexpand.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_hyperexpand.py
new file mode 100644
index 0000000000000000000000000000000000000000..c703c228a13201de13cfd4c3413fc75a2cf5bdb6
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_hyperexpand.py
@@ -0,0 +1,1063 @@
+from sympy.core.random import randrange
+
+from sympy.simplify.hyperexpand import (ShiftA, ShiftB, UnShiftA, UnShiftB,
+ MeijerShiftA, MeijerShiftB, MeijerShiftC, MeijerShiftD,
+ MeijerUnShiftA, MeijerUnShiftB, MeijerUnShiftC,
+ MeijerUnShiftD,
+ ReduceOrder, reduce_order, apply_operators,
+ devise_plan, make_derivative_operator, Formula,
+ hyperexpand, Hyper_Function, G_Function,
+ reduce_order_meijer,
+ build_hypergeometric_formula)
+from sympy.concrete.summations import Sum
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.numbers import I
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.hyper import (hyper, meijerg)
+from sympy.abc import z, a, b, c
+from sympy.testing.pytest import XFAIL, raises, slow, tooslow
+from sympy.core.random import verify_numerically as tn
+
+from sympy.core.numbers import (Rational, pi)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import atanh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (asin, cos, sin)
+from sympy.functions.special.bessel import besseli
+from sympy.functions.special.error_functions import erf
+from sympy.functions.special.gamma_functions import (gamma, lowergamma)
+
+
+def test_branch_bug():
+ assert hyperexpand(hyper((Rational(-1, 3), S.Half), (Rational(2, 3), Rational(3, 2)), -z)) == \
+ -z**S('1/3')*lowergamma(exp_polar(I*pi)/3, z)/5 \
+ + sqrt(pi)*erf(sqrt(z))/(5*sqrt(z))
+ assert hyperexpand(meijerg([Rational(7, 6), 1], [], [Rational(2, 3)], [Rational(1, 6), 0], z)) == \
+ 2*z**S('2/3')*(2*sqrt(pi)*erf(sqrt(z))/sqrt(z) - 2*lowergamma(
+ Rational(2, 3), z)/z**S('2/3'))*gamma(Rational(2, 3))/gamma(Rational(5, 3))
+
+
+def test_hyperexpand():
+ # Luke, Y. L. (1969), The Special Functions and Their Approximations,
+ # Volume 1, section 6.2
+
+ assert hyperexpand(hyper([], [], z)) == exp(z)
+ assert hyperexpand(hyper([1, 1], [2], -z)*z) == log(1 + z)
+ assert hyperexpand(hyper([], [S.Half], -z**2/4)) == cos(z)
+ assert hyperexpand(z*hyper([], [S('3/2')], -z**2/4)) == sin(z)
+ assert hyperexpand(hyper([S('1/2'), S('1/2')], [S('3/2')], z**2)*z) \
+ == asin(z)
+ assert isinstance(Sum(binomial(2, z)*z**2, (z, 0, a)).doit(), Expr)
+
+
+def can_do(ap, bq, numerical=True, div=1, lowerplane=False):
+ r = hyperexpand(hyper(ap, bq, z))
+ if r.has(hyper):
+ return False
+ if not numerical:
+ return True
+ repl = {}
+ randsyms = r.free_symbols - {z}
+ while randsyms:
+ # Only randomly generated parameters are checked.
+ for n, ai in enumerate(randsyms):
+ repl[ai] = randcplx(n)/div
+ if not any(b.is_Integer and b <= 0 for b in Tuple(*bq).subs(repl)):
+ break
+ [a, b, c, d] = [2, -1, 3, 1]
+ if lowerplane:
+ [a, b, c, d] = [2, -2, 3, -1]
+ return tn(
+ hyper(ap, bq, z).subs(repl),
+ r.replace(exp_polar, exp).subs(repl),
+ z, a=a, b=b, c=c, d=d)
+
+
+def test_roach():
+ # Kelly B. Roach. Meijer G Function Representations.
+ # Section "Gallery"
+ assert can_do([S.Half], [Rational(9, 2)])
+ assert can_do([], [1, Rational(5, 2), 4])
+ assert can_do([Rational(-1, 2), 1, 2], [3, 4])
+ assert can_do([Rational(1, 3)], [Rational(-2, 3), Rational(-1, 2), S.Half, 1])
+ assert can_do([Rational(-3, 2), Rational(-1, 2)], [Rational(-5, 2), 1])
+ assert can_do([Rational(-3, 2), ], [Rational(-1, 2), S.Half]) # shine-integral
+ assert can_do([Rational(-3, 2), Rational(-1, 2)], [2]) # elliptic integrals
+
+
+@XFAIL
+def test_roach_fail():
+ assert can_do([Rational(-1, 2), 1], [Rational(1, 4), S.Half, Rational(3, 4)]) # PFDD
+ assert can_do([Rational(3, 2)], [Rational(5, 2), 5]) # struve function
+ assert can_do([Rational(-1, 2), S.Half, 1], [Rational(3, 2), Rational(5, 2)]) # polylog, pfdd
+ assert can_do([1, 2, 3], [S.Half, 4]) # XXX ?
+ assert can_do([S.Half], [Rational(-1, 3), Rational(-1, 2), Rational(-2, 3)]) # PFDD ?
+
+# For the long table tests, see end of file
+
+
+def test_polynomial():
+ from sympy.core.numbers import oo
+ assert hyperexpand(hyper([], [-1], z)) is oo
+ assert hyperexpand(hyper([-2], [-1], z)) is oo
+ assert hyperexpand(hyper([0, 0], [-1], z)) == 1
+ assert can_do([-5, -2, randcplx(), randcplx()], [-10, randcplx()])
+ assert hyperexpand(hyper((-1, 1), (-2,), z)) == 1 + z/2
+
+
+def test_hyperexpand_bases():
+ assert hyperexpand(hyper([2], [a], z)) == \
+ a + z**(-a + 1)*(-a**2 + 3*a + z*(a - 1) - 2)*exp(z)* \
+ lowergamma(a - 1, z) - 1
+ # TODO [a+1, aRational(-1, 2)], [2*a]
+ assert hyperexpand(hyper([1, 2], [3], z)) == -2/z - 2*log(-z + 1)/z**2
+ assert hyperexpand(hyper([S.Half, 2], [Rational(3, 2)], z)) == \
+ -1/(2*z - 2) + atanh(sqrt(z))/sqrt(z)/2
+ assert hyperexpand(hyper([S.Half, S.Half], [Rational(5, 2)], z)) == \
+ (-3*z + 3)/4/(z*sqrt(-z + 1)) \
+ + (6*z - 3)*asin(sqrt(z))/(4*z**Rational(3, 2))
+ assert hyperexpand(hyper([1, 2], [Rational(3, 2)], z)) == -1/(2*z - 2) \
+ - asin(sqrt(z))/(sqrt(z)*(2*z - 2)*sqrt(-z + 1))
+ assert hyperexpand(hyper([Rational(-1, 2) - 1, 1, 2], [S.Half, 3], z)) == \
+ sqrt(z)*(z*Rational(6, 7) - Rational(6, 5))*atanh(sqrt(z)) \
+ + (-30*z**2 + 32*z - 6)/35/z - 6*log(-z + 1)/(35*z**2)
+ assert hyperexpand(hyper([1 + S.Half, 1, 1], [2, 2], z)) == \
+ -4*log(sqrt(-z + 1)/2 + S.Half)/z
+ # TODO hyperexpand(hyper([a], [2*a + 1], z))
+ # TODO [S.Half, a], [Rational(3, 2), a+1]
+ assert hyperexpand(hyper([2], [b, 1], z)) == \
+ z**(-b/2 + S.Half)*besseli(b - 1, 2*sqrt(z))*gamma(b) \
+ + z**(-b/2 + 1)*besseli(b, 2*sqrt(z))*gamma(b)
+ # TODO [a], [a - S.Half, 2*a]
+
+
+def test_hyperexpand_parametric():
+ assert hyperexpand(hyper([a, S.Half + a], [S.Half], z)) \
+ == (1 + sqrt(z))**(-2*a)/2 + (1 - sqrt(z))**(-2*a)/2
+ assert hyperexpand(hyper([a, Rational(-1, 2) + a], [2*a], z)) \
+ == 2**(2*a - 1)*((-z + 1)**S.Half + 1)**(-2*a + 1)
+
+
+def test_shifted_sum():
+ from sympy.simplify.simplify import simplify
+ assert simplify(hyperexpand(z**4*hyper([2], [3, S('3/2')], -z**2))) \
+ == z*sin(2*z) + (-z**2 + S.Half)*cos(2*z) - S.Half
+
+
+def _randrat():
+ """ Steer clear of integers. """
+ return S(randrange(25) + 10)/50
+
+
+def randcplx(offset=-1):
+ """ Polys is not good with real coefficients. """
+ return _randrat() + I*_randrat() + I*(1 + offset)
+
+
+@slow
+def test_formulae():
+ from sympy.simplify.hyperexpand import FormulaCollection
+ formulae = FormulaCollection().formulae
+ for formula in formulae:
+ h = formula.func(formula.z)
+ rep = {}
+ for n, sym in enumerate(formula.symbols):
+ rep[sym] = randcplx(n)
+
+ # NOTE hyperexpand returns truly branched functions. We know we are
+ # on the main sheet, but numerical evaluation can still go wrong
+ # (e.g. if exp_polar cannot be evalf'd).
+ # Just replace all exp_polar by exp, this usually works.
+
+ # first test if the closed-form is actually correct
+ h = h.subs(rep)
+ closed_form = formula.closed_form.subs(rep).rewrite('nonrepsmall')
+ z = formula.z
+ assert tn(h, closed_form.replace(exp_polar, exp), z)
+
+ # now test the computed matrix
+ cl = (formula.C * formula.B)[0].subs(rep).rewrite('nonrepsmall')
+ assert tn(closed_form.replace(
+ exp_polar, exp), cl.replace(exp_polar, exp), z)
+ deriv1 = z*formula.B.applyfunc(lambda t: t.rewrite(
+ 'nonrepsmall')).diff(z)
+ deriv2 = formula.M * formula.B
+ for d1, d2 in zip(deriv1, deriv2):
+ assert tn(d1.subs(rep).replace(exp_polar, exp),
+ d2.subs(rep).rewrite('nonrepsmall').replace(exp_polar, exp), z)
+
+
+def test_meijerg_formulae():
+ from sympy.simplify.hyperexpand import MeijerFormulaCollection
+ formulae = MeijerFormulaCollection().formulae
+ for sig in formulae:
+ for formula in formulae[sig]:
+ g = meijerg(formula.func.an, formula.func.ap,
+ formula.func.bm, formula.func.bq,
+ formula.z)
+ rep = {}
+ for sym in formula.symbols:
+ rep[sym] = randcplx()
+
+ # first test if the closed-form is actually correct
+ g = g.subs(rep)
+ closed_form = formula.closed_form.subs(rep)
+ z = formula.z
+ assert tn(g, closed_form, z)
+
+ # now test the computed matrix
+ cl = (formula.C * formula.B)[0].subs(rep)
+ assert tn(closed_form, cl, z)
+ deriv1 = z*formula.B.diff(z)
+ deriv2 = formula.M * formula.B
+ for d1, d2 in zip(deriv1, deriv2):
+ assert tn(d1.subs(rep), d2.subs(rep), z)
+
+
+def op(f):
+ return z*f.diff(z)
+
+
+def test_plan():
+ assert devise_plan(Hyper_Function([0], ()),
+ Hyper_Function([0], ()), z) == []
+ with raises(ValueError):
+ devise_plan(Hyper_Function([1], ()), Hyper_Function((), ()), z)
+ with raises(ValueError):
+ devise_plan(Hyper_Function([2], [1]), Hyper_Function([2], [2]), z)
+ with raises(ValueError):
+ devise_plan(Hyper_Function([2], []), Hyper_Function([S("1/2")], []), z)
+
+ # We cannot use pi/(10000 + n) because polys is insanely slow.
+ a1, a2, b1 = (randcplx(n) for n in range(3))
+ b1 += 2*I
+ h = hyper([a1, a2], [b1], z)
+
+ h2 = hyper((a1 + 1, a2), [b1], z)
+ assert tn(apply_operators(h,
+ devise_plan(Hyper_Function((a1 + 1, a2), [b1]),
+ Hyper_Function((a1, a2), [b1]), z), op),
+ h2, z)
+
+ h2 = hyper((a1 + 1, a2 - 1), [b1], z)
+ assert tn(apply_operators(h,
+ devise_plan(Hyper_Function((a1 + 1, a2 - 1), [b1]),
+ Hyper_Function((a1, a2), [b1]), z), op),
+ h2, z)
+
+
+def test_plan_derivatives():
+ a1, a2, a3 = 1, 2, S('1/2')
+ b1, b2 = 3, S('5/2')
+ h = Hyper_Function((a1, a2, a3), (b1, b2))
+ h2 = Hyper_Function((a1 + 1, a2 + 1, a3 + 2), (b1 + 1, b2 + 1))
+ ops = devise_plan(h2, h, z)
+ f = Formula(h, z, h(z), [])
+ deriv = make_derivative_operator(f.M, z)
+ assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2(z), z)
+
+ h2 = Hyper_Function((a1, a2 - 1, a3 - 2), (b1 - 1, b2 - 1))
+ ops = devise_plan(h2, h, z)
+ assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2(z), z)
+
+
+def test_reduction_operators():
+ a1, a2, b1 = (randcplx(n) for n in range(3))
+ h = hyper([a1], [b1], z)
+
+ assert ReduceOrder(2, 0) is None
+ assert ReduceOrder(2, -1) is None
+ assert ReduceOrder(1, S('1/2')) is None
+
+ h2 = hyper((a1, a2), (b1, a2), z)
+ assert tn(ReduceOrder(a2, a2).apply(h, op), h2, z)
+
+ h2 = hyper((a1, a2 + 1), (b1, a2), z)
+ assert tn(ReduceOrder(a2 + 1, a2).apply(h, op), h2, z)
+
+ h2 = hyper((a2 + 4, a1), (b1, a2), z)
+ assert tn(ReduceOrder(a2 + 4, a2).apply(h, op), h2, z)
+
+ # test several step order reduction
+ ap = (a2 + 4, a1, b1 + 1)
+ bq = (a2, b1, b1)
+ func, ops = reduce_order(Hyper_Function(ap, bq))
+ assert func.ap == (a1,)
+ assert func.bq == (b1,)
+ assert tn(apply_operators(h, ops, op), hyper(ap, bq, z), z)
+
+
+def test_shift_operators():
+ a1, a2, b1, b2, b3 = (randcplx(n) for n in range(5))
+ h = hyper((a1, a2), (b1, b2, b3), z)
+
+ raises(ValueError, lambda: ShiftA(0))
+ raises(ValueError, lambda: ShiftB(1))
+
+ assert tn(ShiftA(a1).apply(h, op), hyper((a1 + 1, a2), (b1, b2, b3), z), z)
+ assert tn(ShiftA(a2).apply(h, op), hyper((a1, a2 + 1), (b1, b2, b3), z), z)
+ assert tn(ShiftB(b1).apply(h, op), hyper((a1, a2), (b1 - 1, b2, b3), z), z)
+ assert tn(ShiftB(b2).apply(h, op), hyper((a1, a2), (b1, b2 - 1, b3), z), z)
+ assert tn(ShiftB(b3).apply(h, op), hyper((a1, a2), (b1, b2, b3 - 1), z), z)
+
+
+def test_ushift_operators():
+ a1, a2, b1, b2, b3 = (randcplx(n) for n in range(5))
+ h = hyper((a1, a2), (b1, b2, b3), z)
+
+ raises(ValueError, lambda: UnShiftA((1,), (), 0, z))
+ raises(ValueError, lambda: UnShiftB((), (-1,), 0, z))
+ raises(ValueError, lambda: UnShiftA((1,), (0, -1, 1), 0, z))
+ raises(ValueError, lambda: UnShiftB((0, 1), (1,), 0, z))
+
+ s = UnShiftA((a1, a2), (b1, b2, b3), 0, z)
+ assert tn(s.apply(h, op), hyper((a1 - 1, a2), (b1, b2, b3), z), z)
+ s = UnShiftA((a1, a2), (b1, b2, b3), 1, z)
+ assert tn(s.apply(h, op), hyper((a1, a2 - 1), (b1, b2, b3), z), z)
+
+ s = UnShiftB((a1, a2), (b1, b2, b3), 0, z)
+ assert tn(s.apply(h, op), hyper((a1, a2), (b1 + 1, b2, b3), z), z)
+ s = UnShiftB((a1, a2), (b1, b2, b3), 1, z)
+ assert tn(s.apply(h, op), hyper((a1, a2), (b1, b2 + 1, b3), z), z)
+ s = UnShiftB((a1, a2), (b1, b2, b3), 2, z)
+ assert tn(s.apply(h, op), hyper((a1, a2), (b1, b2, b3 + 1), z), z)
+
+
+def can_do_meijer(a1, a2, b1, b2, numeric=True):
+ """
+ This helper function tries to hyperexpand() the meijer g-function
+ corresponding to the parameters a1, a2, b1, b2.
+ It returns False if this expansion still contains g-functions.
+ If numeric is True, it also tests the so-obtained formula numerically
+ (at random values) and returns False if the test fails.
+ Else it returns True.
+ """
+ from sympy.core.function import expand
+ from sympy.functions.elementary.complexes import unpolarify
+ r = hyperexpand(meijerg(a1, a2, b1, b2, z))
+ if r.has(meijerg):
+ return False
+ # NOTE hyperexpand() returns a truly branched function, whereas numerical
+ # evaluation only works on the main branch. Since we are evaluating on
+ # the main branch, this should not be a problem, but expressions like
+ # exp_polar(I*pi/2*x)**a are evaluated incorrectly. We thus have to get
+ # rid of them. The expand heuristically does this...
+ r = unpolarify(expand(r, force=True, power_base=True, power_exp=False,
+ mul=False, log=False, multinomial=False, basic=False))
+
+ if not numeric:
+ return True
+
+ repl = {}
+ for n, ai in enumerate(meijerg(a1, a2, b1, b2, z).free_symbols - {z}):
+ repl[ai] = randcplx(n)
+ return tn(meijerg(a1, a2, b1, b2, z).subs(repl), r.subs(repl), z)
+
+
+@slow
+def test_meijerg_expand():
+ from sympy.simplify.gammasimp import gammasimp
+ from sympy.simplify.simplify import simplify
+ # from mpmath docs
+ assert hyperexpand(meijerg([[], []], [[0], []], -z)) == exp(z)
+
+ assert hyperexpand(meijerg([[1, 1], []], [[1], [0]], z)) == \
+ log(z + 1)
+ assert hyperexpand(meijerg([[1, 1], []], [[1], [1]], z)) == \
+ z/(z + 1)
+ assert hyperexpand(meijerg([[], []], [[S.Half], [0]], (z/2)**2)) \
+ == sin(z)/sqrt(pi)
+ assert hyperexpand(meijerg([[], []], [[0], [S.Half]], (z/2)**2)) \
+ == cos(z)/sqrt(pi)
+ assert can_do_meijer([], [a], [a - 1, a - S.Half], [])
+ assert can_do_meijer([], [], [a/2], [-a/2], False) # branches...
+ assert can_do_meijer([a], [b], [a], [b, a - 1])
+
+ # wikipedia
+ assert hyperexpand(meijerg([1], [], [], [0], z)) == \
+ Piecewise((0, abs(z) < 1), (1, abs(1/z) < 1),
+ (meijerg([1], [], [], [0], z), True))
+ assert hyperexpand(meijerg([], [1], [0], [], z)) == \
+ Piecewise((1, abs(z) < 1), (0, abs(1/z) < 1),
+ (meijerg([], [1], [0], [], z), True))
+
+ # The Special Functions and their Approximations
+ assert can_do_meijer([], [], [a + b/2], [a, a - b/2, a + S.Half])
+ assert can_do_meijer(
+ [], [], [a], [b], False) # branches only agree for small z
+ assert can_do_meijer([], [S.Half], [a], [-a])
+ assert can_do_meijer([], [], [a, b], [])
+ assert can_do_meijer([], [], [a, b], [])
+ assert can_do_meijer([], [], [a, a + S.Half], [b, b + S.Half])
+ assert can_do_meijer([], [], [a, -a], [0, S.Half], False) # dito
+ assert can_do_meijer([], [], [a, a + S.Half, b, b + S.Half], [])
+ assert can_do_meijer([S.Half], [], [0], [a, -a])
+ assert can_do_meijer([S.Half], [], [a], [0, -a], False) # dito
+ assert can_do_meijer([], [a - S.Half], [a, b], [a - S.Half], False)
+ assert can_do_meijer([], [a + S.Half], [a + b, a - b, a], [], False)
+ assert can_do_meijer([a + S.Half], [], [b, 2*a - b, a], [], False)
+
+ # This for example is actually zero.
+ assert can_do_meijer([], [], [], [a, b])
+
+ # Testing a bug:
+ assert hyperexpand(meijerg([0, 2], [], [], [-1, 1], z)) == \
+ Piecewise((0, abs(z) < 1),
+ (z*(1 - 1/z**2)/2, abs(1/z) < 1),
+ (meijerg([0, 2], [], [], [-1, 1], z), True))
+
+ # Test that the simplest possible answer is returned:
+ assert gammasimp(simplify(hyperexpand(
+ meijerg([1], [1 - a], [-a/2, -a/2 + S.Half], [], 1/z)))) == \
+ -2*sqrt(pi)*(sqrt(z + 1) + 1)**a/a
+
+ # Test that hyper is returned
+ assert hyperexpand(meijerg([1], [], [a], [0, 0], z)) == hyper(
+ (a,), (a + 1, a + 1), z*exp_polar(I*pi))*z**a*gamma(a)/gamma(a + 1)**2
+
+ # Test place option
+ f = meijerg(((0, 1), ()), ((S.Half,), (0,)), z**2)
+ assert hyperexpand(f) == sqrt(pi)/sqrt(1 + z**(-2))
+ assert hyperexpand(f, place=0) == sqrt(pi)*z/sqrt(z**2 + 1)
+
+
+def test_meijerg_lookup():
+ from sympy.functions.special.error_functions import (Ci, Si)
+ from sympy.functions.special.gamma_functions import uppergamma
+ assert hyperexpand(meijerg([a], [], [b, a], [], z)) == \
+ z**b*exp(z)*gamma(-a + b + 1)*uppergamma(a - b, z)
+ assert hyperexpand(meijerg([0], [], [0, 0], [], z)) == \
+ exp(z)*uppergamma(0, z)
+ assert can_do_meijer([a], [], [b, a + 1], [])
+ assert can_do_meijer([a], [], [b + 2, a], [])
+ assert can_do_meijer([a], [], [b - 2, a], [])
+
+ assert hyperexpand(meijerg([a], [], [a, a, a - S.Half], [], z)) == \
+ -sqrt(pi)*z**(a - S.Half)*(2*cos(2*sqrt(z))*(Si(2*sqrt(z)) - pi/2)
+ - 2*sin(2*sqrt(z))*Ci(2*sqrt(z))) == \
+ hyperexpand(meijerg([a], [], [a, a - S.Half, a], [], z)) == \
+ hyperexpand(meijerg([a], [], [a - S.Half, a, a], [], z))
+ assert can_do_meijer([a - 1], [], [a + 2, a - Rational(3, 2), a + 1], [])
+
+
+@XFAIL
+def test_meijerg_expand_fail():
+ # These basically test hyper([], [1/2 - a, 1/2 + 1, 1/2], z),
+ # which is *very* messy. But since the meijer g actually yields a
+ # sum of bessel functions, things can sometimes be simplified a lot and
+ # are then put into tables...
+ assert can_do_meijer([], [], [a + S.Half], [a, a - b/2, a + b/2])
+ assert can_do_meijer([], [], [0, S.Half], [a, -a])
+ assert can_do_meijer([], [], [3*a - S.Half, a, -a - S.Half], [a - S.Half])
+ assert can_do_meijer([], [], [0, a - S.Half, -a - S.Half], [S.Half])
+ assert can_do_meijer([], [], [a, b + S.Half, b], [2*b - a])
+ assert can_do_meijer([], [], [a, b + S.Half, b, 2*b - a])
+ assert can_do_meijer([S.Half], [], [-a, a], [0])
+
+
+@slow
+def test_meijerg():
+ # carefully set up the parameters.
+ # NOTE: this used to fail sometimes. I believe it is fixed, but if you
+ # hit an inexplicable test failure here, please let me know the seed.
+ a1, a2 = (randcplx(n) - 5*I - n*I for n in range(2))
+ b1, b2 = (randcplx(n) + 5*I + n*I for n in range(2))
+ b3, b4, b5, a3, a4, a5 = (randcplx() for n in range(6))
+ g = meijerg([a1], [a3, a4], [b1], [b3, b4], z)
+
+ assert ReduceOrder.meijer_minus(3, 4) is None
+ assert ReduceOrder.meijer_plus(4, 3) is None
+
+ g2 = meijerg([a1, a2], [a3, a4], [b1], [b3, b4, a2], z)
+ assert tn(ReduceOrder.meijer_plus(a2, a2).apply(g, op), g2, z)
+
+ g2 = meijerg([a1, a2], [a3, a4], [b1], [b3, b4, a2 + 1], z)
+ assert tn(ReduceOrder.meijer_plus(a2, a2 + 1).apply(g, op), g2, z)
+
+ g2 = meijerg([a1, a2 - 1], [a3, a4], [b1], [b3, b4, a2 + 2], z)
+ assert tn(ReduceOrder.meijer_plus(a2 - 1, a2 + 2).apply(g, op), g2, z)
+
+ g2 = meijerg([a1], [a3, a4, b2 - 1], [b1, b2 + 2], [b3, b4], z)
+ assert tn(ReduceOrder.meijer_minus(
+ b2 + 2, b2 - 1).apply(g, op), g2, z, tol=1e-6)
+
+ # test several-step reduction
+ an = [a1, a2]
+ bq = [b3, b4, a2 + 1]
+ ap = [a3, a4, b2 - 1]
+ bm = [b1, b2 + 1]
+ niq, ops = reduce_order_meijer(G_Function(an, ap, bm, bq))
+ assert niq.an == (a1,)
+ assert set(niq.ap) == {a3, a4}
+ assert niq.bm == (b1,)
+ assert set(niq.bq) == {b3, b4}
+ assert tn(apply_operators(g, ops, op), meijerg(an, ap, bm, bq, z), z)
+
+
+def test_meijerg_shift_operators():
+ # carefully set up the parameters. XXX this still fails sometimes
+ a1, a2, a3, a4, a5, b1, b2, b3, b4, b5 = (randcplx(n) for n in range(10))
+ g = meijerg([a1], [a3, a4], [b1], [b3, b4], z)
+
+ assert tn(MeijerShiftA(b1).apply(g, op),
+ meijerg([a1], [a3, a4], [b1 + 1], [b3, b4], z), z)
+ assert tn(MeijerShiftB(a1).apply(g, op),
+ meijerg([a1 - 1], [a3, a4], [b1], [b3, b4], z), z)
+ assert tn(MeijerShiftC(b3).apply(g, op),
+ meijerg([a1], [a3, a4], [b1], [b3 + 1, b4], z), z)
+ assert tn(MeijerShiftD(a3).apply(g, op),
+ meijerg([a1], [a3 - 1, a4], [b1], [b3, b4], z), z)
+
+ s = MeijerUnShiftA([a1], [a3, a4], [b1], [b3, b4], 0, z)
+ assert tn(
+ s.apply(g, op), meijerg([a1], [a3, a4], [b1 - 1], [b3, b4], z), z)
+
+ s = MeijerUnShiftC([a1], [a3, a4], [b1], [b3, b4], 0, z)
+ assert tn(
+ s.apply(g, op), meijerg([a1], [a3, a4], [b1], [b3 - 1, b4], z), z)
+
+ s = MeijerUnShiftB([a1], [a3, a4], [b1], [b3, b4], 0, z)
+ assert tn(
+ s.apply(g, op), meijerg([a1 + 1], [a3, a4], [b1], [b3, b4], z), z)
+
+ s = MeijerUnShiftD([a1], [a3, a4], [b1], [b3, b4], 0, z)
+ assert tn(
+ s.apply(g, op), meijerg([a1], [a3 + 1, a4], [b1], [b3, b4], z), z)
+
+
+@slow
+def test_meijerg_confluence():
+ def t(m, a, b):
+ from sympy.core.sympify import sympify
+ a, b = sympify([a, b])
+ m_ = m
+ m = hyperexpand(m)
+ if not m == Piecewise((a, abs(z) < 1), (b, abs(1/z) < 1), (m_, True)):
+ return False
+ if not (m.args[0].args[0] == a and m.args[1].args[0] == b):
+ return False
+ z0 = randcplx()/10
+ if abs(m.subs(z, z0).n() - a.subs(z, z0).n()).n() > 1e-10:
+ return False
+ if abs(m.subs(z, 1/z0).n() - b.subs(z, 1/z0).n()).n() > 1e-10:
+ return False
+ return True
+
+ assert t(meijerg([], [1, 1], [0, 0], [], z), -log(z), 0)
+ assert t(meijerg(
+ [], [3, 1], [0, 0], [], z), -z**2/4 + z - log(z)/2 - Rational(3, 4), 0)
+ assert t(meijerg([], [3, 1], [-1, 0], [], z),
+ z**2/12 - z/2 + log(z)/2 + Rational(1, 4) + 1/(6*z), 0)
+ assert t(meijerg([], [1, 1, 1, 1], [0, 0, 0, 0], [], z), -log(z)**3/6, 0)
+ assert t(meijerg([1, 1], [], [], [0, 0], z), 0, -log(1/z))
+ assert t(meijerg([1, 1], [2, 2], [1, 1], [0, 0], z),
+ -z*log(z) + 2*z, -log(1/z) + 2)
+ assert t(meijerg([S.Half], [1, 1], [0, 0], [Rational(3, 2)], z), log(z)/2 - 1, 0)
+
+ def u(an, ap, bm, bq):
+ m = meijerg(an, ap, bm, bq, z)
+ m2 = hyperexpand(m, allow_hyper=True)
+ if m2.has(meijerg) and not (m2.is_Piecewise and len(m2.args) == 3):
+ return False
+ return tn(m, m2, z)
+ assert u([], [1], [0, 0], [])
+ assert u([1, 1], [], [], [0])
+ assert u([1, 1], [2, 2, 5], [1, 1, 6], [0, 0])
+ assert u([1, 1], [2, 2, 5], [1, 1, 6], [0])
+
+
+def test_meijerg_with_Floats():
+ # see issue #10681
+ from sympy.polys.domains.realfield import RR
+ f = meijerg(((3.0, 1), ()), ((Rational(3, 2),), (0,)), z)
+ a = -2.3632718012073
+ g = a*z**Rational(3, 2)*hyper((-0.5, Rational(3, 2)), (Rational(5, 2),), z*exp_polar(I*pi))
+ assert RR.almosteq((hyperexpand(f)/g).n(), 1.0, 1e-12)
+
+
+def test_lerchphi():
+ from sympy.functions.special.zeta_functions import (lerchphi, polylog)
+ from sympy.simplify.gammasimp import gammasimp
+ assert hyperexpand(hyper([1, a], [a + 1], z)/a) == lerchphi(z, 1, a)
+ assert hyperexpand(
+ hyper([1, a, a], [a + 1, a + 1], z)/a**2) == lerchphi(z, 2, a)
+ assert hyperexpand(hyper([1, a, a, a], [a + 1, a + 1, a + 1], z)/a**3) == \
+ lerchphi(z, 3, a)
+ assert hyperexpand(hyper([1] + [a]*10, [a + 1]*10, z)/a**10) == \
+ lerchphi(z, 10, a)
+ assert gammasimp(hyperexpand(meijerg([0, 1 - a], [], [0],
+ [-a], exp_polar(-I*pi)*z))) == lerchphi(z, 1, a)
+ assert gammasimp(hyperexpand(meijerg([0, 1 - a, 1 - a], [], [0],
+ [-a, -a], exp_polar(-I*pi)*z))) == lerchphi(z, 2, a)
+ assert gammasimp(hyperexpand(meijerg([0, 1 - a, 1 - a, 1 - a], [], [0],
+ [-a, -a, -a], exp_polar(-I*pi)*z))) == lerchphi(z, 3, a)
+
+ assert hyperexpand(z*hyper([1, 1], [2], z)) == -log(1 + -z)
+ assert hyperexpand(z*hyper([1, 1, 1], [2, 2], z)) == polylog(2, z)
+ assert hyperexpand(z*hyper([1, 1, 1, 1], [2, 2, 2], z)) == polylog(3, z)
+
+ assert hyperexpand(hyper([1, a, 1 + S.Half], [a + 1, S.Half], z)) == \
+ -2*a/(z - 1) + (-2*a**2 + a)*lerchphi(z, 1, a)
+
+ # Now numerical tests. These make sure reductions etc are carried out
+ # correctly
+
+ # a rational function (polylog at negative integer order)
+ assert can_do([2, 2, 2], [1, 1])
+
+ # NOTE these contain log(1-x) etc ... better make sure we have |z| < 1
+ # reduction of order for polylog
+ assert can_do([1, 1, 1, b + 5], [2, 2, b], div=10)
+
+ # reduction of order for lerchphi
+ # XXX lerchphi in mpmath is flaky
+ assert can_do(
+ [1, a, a, a, b + 5], [a + 1, a + 1, a + 1, b], numerical=False)
+
+ # test a bug
+ from sympy.functions.elementary.complexes import Abs
+ assert hyperexpand(hyper([S.Half, S.Half, S.Half, 1],
+ [Rational(3, 2), Rational(3, 2), Rational(3, 2)], Rational(1, 4))) == \
+ Abs(-polylog(3, exp_polar(I*pi)/2) + polylog(3, S.Half))
+
+
+def test_partial_simp():
+ # First test that hypergeometric function formulae work.
+ a, b, c, d, e = (randcplx() for _ in range(5))
+ for func in [Hyper_Function([a, b, c], [d, e]),
+ Hyper_Function([], [a, b, c, d, e])]:
+ f = build_hypergeometric_formula(func)
+ z = f.z
+ assert f.closed_form == func(z)
+ deriv1 = f.B.diff(z)*z
+ deriv2 = f.M*f.B
+ for func1, func2 in zip(deriv1, deriv2):
+ assert tn(func1, func2, z)
+
+ # Now test that formulae are partially simplified.
+ a, b, z = symbols('a b z')
+ assert hyperexpand(hyper([3, a], [1, b], z)) == \
+ (-a*b/2 + a*z/2 + 2*a)*hyper([a + 1], [b], z) \
+ + (a*b/2 - 2*a + 1)*hyper([a], [b], z)
+ assert tn(
+ hyperexpand(hyper([3, d], [1, e], z)), hyper([3, d], [1, e], z), z)
+ assert hyperexpand(hyper([3], [1, a, b], z)) == \
+ hyper((), (a, b), z) \
+ + z*hyper((), (a + 1, b), z)/(2*a) \
+ - z*(b - 4)*hyper((), (a + 1, b + 1), z)/(2*a*b)
+ assert tn(
+ hyperexpand(hyper([3], [1, d, e], z)), hyper([3], [1, d, e], z), z)
+
+
+def test_hyperexpand_special():
+ assert hyperexpand(hyper([a, b], [c], 1)) == \
+ gamma(c)*gamma(c - a - b)/gamma(c - a)/gamma(c - b)
+ assert hyperexpand(hyper([a, b], [1 + a - b], -1)) == \
+ gamma(1 + a/2)*gamma(1 + a - b)/gamma(1 + a)/gamma(1 + a/2 - b)
+ assert hyperexpand(hyper([a, b], [1 + b - a], -1)) == \
+ gamma(1 + b/2)*gamma(1 + b - a)/gamma(1 + b)/gamma(1 + b/2 - a)
+ assert hyperexpand(meijerg([1 - z - a/2], [1 - z + a/2], [b/2], [-b/2], 1)) == \
+ gamma(1 - 2*z)*gamma(z + a/2 + b/2)/gamma(1 - z + a/2 - b/2) \
+ /gamma(1 - z - a/2 + b/2)/gamma(1 - z + a/2 + b/2)
+ assert hyperexpand(hyper([a], [b], 0)) == 1
+ assert hyper([a], [b], 0) != 0
+
+
+def test_Mod1_behavior():
+ from sympy.core.symbol import Symbol
+ from sympy.simplify.simplify import simplify
+ n = Symbol('n', integer=True)
+ # Note: this should not hang.
+ assert simplify(hyperexpand(meijerg([1], [], [n + 1], [0], z))) == \
+ lowergamma(n + 1, z)
+
+
+@slow
+def test_prudnikov_misc():
+ assert can_do([1, (3 + I)/2, (3 - I)/2], [Rational(3, 2), 2])
+ assert can_do([S.Half, a - 1], [Rational(3, 2), a + 1], lowerplane=True)
+ assert can_do([], [b + 1])
+ assert can_do([a], [a - 1, b + 1])
+
+ assert can_do([a], [a - S.Half, 2*a])
+ assert can_do([a], [a - S.Half, 2*a + 1])
+ assert can_do([a], [a - S.Half, 2*a - 1])
+ assert can_do([a], [a + S.Half, 2*a])
+ assert can_do([a], [a + S.Half, 2*a + 1])
+ assert can_do([a], [a + S.Half, 2*a - 1])
+ assert can_do([S.Half], [b, 2 - b])
+ assert can_do([S.Half], [b, 3 - b])
+ assert can_do([1], [2, b])
+
+ assert can_do([a, a + S.Half], [2*a, b, 2*a - b + 1])
+ assert can_do([a, a + S.Half], [S.Half, 2*a, 2*a + S.Half])
+ assert can_do([a], [a + 1], lowerplane=True) # lowergamma
+
+
+def test_prudnikov_1():
+ # A. P. Prudnikov, Yu. A. Brychkov and O. I. Marichev (1990).
+ # Integrals and Series: More Special Functions, Vol. 3,.
+ # Gordon and Breach Science Publisher
+
+ # 7.3.1
+ assert can_do([a, -a], [S.Half])
+ assert can_do([a, 1 - a], [S.Half])
+ assert can_do([a, 1 - a], [Rational(3, 2)])
+ assert can_do([a, 2 - a], [S.Half])
+ assert can_do([a, 2 - a], [Rational(3, 2)])
+ assert can_do([a, 2 - a], [Rational(3, 2)])
+ assert can_do([a, a + S.Half], [2*a - 1])
+ assert can_do([a, a + S.Half], [2*a])
+ assert can_do([a, a + S.Half], [2*a + 1])
+ assert can_do([a, a + S.Half], [S.Half])
+ assert can_do([a, a + S.Half], [Rational(3, 2)])
+ assert can_do([a, a/2 + 1], [a/2])
+ assert can_do([1, b], [2])
+ assert can_do([1, b], [b + 1], numerical=False) # Lerch Phi
+ # NOTE: branches are complicated for |z| > 1
+
+ assert can_do([a], [2*a])
+ assert can_do([a], [2*a + 1])
+ assert can_do([a], [2*a - 1])
+
+
+@slow
+def test_prudnikov_2():
+ h = S.Half
+ assert can_do([-h, -h], [h])
+ assert can_do([-h, h], [3*h])
+ assert can_do([-h, h], [5*h])
+ assert can_do([-h, h], [7*h])
+ assert can_do([-h, 1], [h])
+
+ for p in [-h, h]:
+ for n in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4]:
+ for m in [-h, h, 3*h, 5*h, 7*h]:
+ assert can_do([p, n], [m])
+ for n in [1, 2, 3, 4]:
+ for m in [1, 2, 3, 4]:
+ assert can_do([p, n], [m])
+
+
+def test_prudnikov_3():
+ h = S.Half
+ assert can_do([Rational(1, 4), Rational(3, 4)], [h])
+ assert can_do([Rational(1, 4), Rational(3, 4)], [3*h])
+ assert can_do([Rational(1, 3), Rational(2, 3)], [3*h])
+ assert can_do([Rational(3, 4), Rational(5, 4)], [h])
+ assert can_do([Rational(3, 4), Rational(5, 4)], [3*h])
+
+
+@tooslow
+def test_prudnikov_3_slow():
+ # XXX: This is marked as tooslow and hence skipped in CI. None of the
+ # individual cases below fails or hangs. Some cases are slow and the loops
+ # below generate 280 different cases. Is it really necessary to test all
+ # 280 cases here?
+ h = S.Half
+ for p in [1, 2, 3, 4]:
+ for n in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4, 9*h]:
+ for m in [1, 3*h, 2, 5*h, 3, 7*h, 4]:
+ assert can_do([p, m], [n])
+
+
+@slow
+def test_prudnikov_4():
+ h = S.Half
+ for p in [3*h, 5*h, 7*h]:
+ for n in [-h, h, 3*h, 5*h, 7*h]:
+ for m in [3*h, 2, 5*h, 3, 7*h, 4]:
+ assert can_do([p, m], [n])
+ for n in [1, 2, 3, 4]:
+ for m in [2, 3, 4]:
+ assert can_do([p, m], [n])
+
+
+@slow
+def test_prudnikov_5():
+ h = S.Half
+
+ for p in [1, 2, 3]:
+ for q in range(p, 4):
+ for r in [1, 2, 3]:
+ for s in range(r, 4):
+ assert can_do([-h, p, q], [r, s])
+
+ for p in [h, 1, 3*h, 2, 5*h, 3]:
+ for q in [h, 3*h, 5*h]:
+ for r in [h, 3*h, 5*h]:
+ for s in [h, 3*h, 5*h]:
+ if s <= q and s <= r:
+ assert can_do([-h, p, q], [r, s])
+
+ for p in [h, 1, 3*h, 2, 5*h, 3]:
+ for q in [1, 2, 3]:
+ for r in [h, 3*h, 5*h]:
+ for s in [1, 2, 3]:
+ assert can_do([-h, p, q], [r, s])
+
+
+@slow
+def test_prudnikov_6():
+ h = S.Half
+
+ for m in [3*h, 5*h]:
+ for n in [1, 2, 3]:
+ for q in [h, 1, 2]:
+ for p in [1, 2, 3]:
+ assert can_do([h, q, p], [m, n])
+ for q in [1, 2, 3]:
+ for p in [3*h, 5*h]:
+ assert can_do([h, q, p], [m, n])
+
+ for q in [1, 2]:
+ for p in [1, 2, 3]:
+ for m in [1, 2, 3]:
+ for n in [1, 2, 3]:
+ assert can_do([h, q, p], [m, n])
+
+ assert can_do([h, h, 5*h], [3*h, 3*h])
+ assert can_do([h, 1, 5*h], [3*h, 3*h])
+ assert can_do([h, 2, 2], [1, 3])
+
+ # pages 435 to 457 contain more PFDD and stuff like this
+
+
+@slow
+def test_prudnikov_7():
+ assert can_do([3], [6])
+
+ h = S.Half
+ for n in [h, 3*h, 5*h, 7*h]:
+ assert can_do([-h], [n])
+ for m in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4]: # HERE
+ for n in [-h, h, 3*h, 5*h, 7*h, 1, 2, 3, 4]:
+ assert can_do([m], [n])
+
+
+@slow
+def test_prudnikov_8():
+ h = S.Half
+
+ # 7.12.2
+ for ai in [1, 2, 3]:
+ for bi in [1, 2, 3]:
+ for ci in range(1, ai + 1):
+ for di in [h, 1, 3*h, 2, 5*h, 3]:
+ assert can_do([ai, bi], [ci, di])
+ for bi in [3*h, 5*h]:
+ for ci in [h, 1, 3*h, 2, 5*h, 3]:
+ for di in [1, 2, 3]:
+ assert can_do([ai, bi], [ci, di])
+
+ for ai in [-h, h, 3*h, 5*h]:
+ for bi in [1, 2, 3]:
+ for ci in [h, 1, 3*h, 2, 5*h, 3]:
+ for di in [1, 2, 3]:
+ assert can_do([ai, bi], [ci, di])
+ for bi in [h, 3*h, 5*h]:
+ for ci in [h, 3*h, 5*h, 3]:
+ for di in [h, 1, 3*h, 2, 5*h, 3]:
+ if ci <= bi:
+ assert can_do([ai, bi], [ci, di])
+
+
+def test_prudnikov_9():
+ # 7.13.1 [we have a general formula ... so this is a bit pointless]
+ for i in range(9):
+ assert can_do([], [(S(i) + 1)/2])
+ for i in range(5):
+ assert can_do([], [-(2*S(i) + 1)/2])
+
+
+@slow
+def test_prudnikov_10():
+ # 7.14.2
+ h = S.Half
+ for p in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4]:
+ for m in [1, 2, 3, 4]:
+ for n in range(m, 5):
+ assert can_do([p], [m, n])
+
+ for p in [1, 2, 3, 4]:
+ for n in [h, 3*h, 5*h, 7*h]:
+ for m in [1, 2, 3, 4]:
+ assert can_do([p], [n, m])
+
+ for p in [3*h, 5*h, 7*h]:
+ for m in [h, 1, 2, 5*h, 3, 7*h, 4]:
+ assert can_do([p], [h, m])
+ assert can_do([p], [3*h, m])
+
+ for m in [h, 1, 2, 5*h, 3, 7*h, 4]:
+ assert can_do([7*h], [5*h, m])
+
+ assert can_do([Rational(-1, 2)], [S.Half, S.Half]) # shine-integral shi
+
+
+def test_prudnikov_11():
+ # 7.15
+ assert can_do([a, a + S.Half], [2*a, b, 2*a - b])
+ assert can_do([a, a + S.Half], [Rational(3, 2), 2*a, 2*a - S.Half])
+
+ assert can_do([Rational(1, 4), Rational(3, 4)], [S.Half, S.Half, 1])
+ assert can_do([Rational(5, 4), Rational(3, 4)], [Rational(3, 2), S.Half, 2])
+ assert can_do([Rational(5, 4), Rational(3, 4)], [Rational(3, 2), Rational(3, 2), 1])
+ assert can_do([Rational(5, 4), Rational(7, 4)], [Rational(3, 2), Rational(5, 2), 2])
+
+ assert can_do([1, 1], [Rational(3, 2), 2, 2]) # cosh-integral chi
+
+
+def test_prudnikov_12():
+ # 7.16
+ assert can_do(
+ [], [a, a + S.Half, 2*a], False) # branches only agree for some z!
+ assert can_do([], [a, a + S.Half, 2*a + 1], False) # dito
+ assert can_do([], [S.Half, a, a + S.Half])
+ assert can_do([], [Rational(3, 2), a, a + S.Half])
+
+ assert can_do([], [Rational(1, 4), S.Half, Rational(3, 4)])
+ assert can_do([], [S.Half, S.Half, 1])
+ assert can_do([], [S.Half, Rational(3, 2), 1])
+ assert can_do([], [Rational(3, 4), Rational(3, 2), Rational(5, 4)])
+ assert can_do([], [1, 1, Rational(3, 2)])
+ assert can_do([], [1, 2, Rational(3, 2)])
+ assert can_do([], [1, Rational(3, 2), Rational(3, 2)])
+ assert can_do([], [Rational(5, 4), Rational(3, 2), Rational(7, 4)])
+ assert can_do([], [2, Rational(3, 2), Rational(3, 2)])
+
+
+@slow
+def test_prudnikov_2F1():
+ h = S.Half
+ # Elliptic integrals
+ for p in [-h, h]:
+ for m in [h, 3*h, 5*h, 7*h]:
+ for n in [1, 2, 3, 4]:
+ assert can_do([p, m], [n])
+
+
+@XFAIL
+def test_prudnikov_fail_2F1():
+ assert can_do([a, b], [b + 1]) # incomplete beta function
+ assert can_do([-1, b], [c]) # Poly. also -2, -3 etc
+
+ # TODO polys
+
+ # Legendre functions:
+ assert can_do([a, b], [a + b + S.Half])
+ assert can_do([a, b], [a + b - S.Half])
+ assert can_do([a, b], [a + b + Rational(3, 2)])
+ assert can_do([a, b], [(a + b + 1)/2])
+ assert can_do([a, b], [(a + b)/2 + 1])
+ assert can_do([a, b], [a - b + 1])
+ assert can_do([a, b], [a - b + 2])
+ assert can_do([a, b], [2*b])
+ assert can_do([a, b], [S.Half])
+ assert can_do([a, b], [Rational(3, 2)])
+ assert can_do([a, 1 - a], [c])
+ assert can_do([a, 2 - a], [c])
+ assert can_do([a, 3 - a], [c])
+ assert can_do([a, a + S.Half], [c])
+ assert can_do([1, b], [c])
+ assert can_do([1, b], [Rational(3, 2)])
+
+ assert can_do([Rational(1, 4), Rational(3, 4)], [1])
+
+ # PFDD
+ o = S.One
+ assert can_do([o/8, 1], [o/8*9])
+ assert can_do([o/6, 1], [o/6*7])
+ assert can_do([o/6, 1], [o/6*13])
+ assert can_do([o/5, 1], [o/5*6])
+ assert can_do([o/5, 1], [o/5*11])
+ assert can_do([o/4, 1], [o/4*5])
+ assert can_do([o/4, 1], [o/4*9])
+ assert can_do([o/3, 1], [o/3*4])
+ assert can_do([o/3, 1], [o/3*7])
+ assert can_do([o/8*3, 1], [o/8*11])
+ assert can_do([o/5*2, 1], [o/5*7])
+ assert can_do([o/5*2, 1], [o/5*12])
+ assert can_do([o/5*3, 1], [o/5*8])
+ assert can_do([o/5*3, 1], [o/5*13])
+ assert can_do([o/8*5, 1], [o/8*13])
+ assert can_do([o/4*3, 1], [o/4*7])
+ assert can_do([o/4*3, 1], [o/4*11])
+ assert can_do([o/3*2, 1], [o/3*5])
+ assert can_do([o/3*2, 1], [o/3*8])
+ assert can_do([o/5*4, 1], [o/5*9])
+ assert can_do([o/5*4, 1], [o/5*14])
+ assert can_do([o/6*5, 1], [o/6*11])
+ assert can_do([o/6*5, 1], [o/6*17])
+ assert can_do([o/8*7, 1], [o/8*15])
+
+
+@XFAIL
+def test_prudnikov_fail_3F2():
+ assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [Rational(1, 3), Rational(2, 3)])
+ assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [Rational(2, 3), Rational(4, 3)])
+ assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [Rational(4, 3), Rational(5, 3)])
+
+ # page 421
+ assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [a*Rational(3, 2), (3*a + 1)/2])
+
+ # pages 422 ...
+ assert can_do([Rational(-1, 2), S.Half, S.Half], [1, 1]) # elliptic integrals
+ assert can_do([Rational(-1, 2), S.Half, 1], [Rational(3, 2), Rational(3, 2)])
+ # TODO LOTS more
+
+ # PFDD
+ assert can_do([Rational(1, 8), Rational(3, 8), 1], [Rational(9, 8), Rational(11, 8)])
+ assert can_do([Rational(1, 8), Rational(5, 8), 1], [Rational(9, 8), Rational(13, 8)])
+ assert can_do([Rational(1, 8), Rational(7, 8), 1], [Rational(9, 8), Rational(15, 8)])
+ assert can_do([Rational(1, 6), Rational(1, 3), 1], [Rational(7, 6), Rational(4, 3)])
+ assert can_do([Rational(1, 6), Rational(2, 3), 1], [Rational(7, 6), Rational(5, 3)])
+ assert can_do([Rational(1, 6), Rational(2, 3), 1], [Rational(5, 3), Rational(13, 6)])
+ assert can_do([S.Half, 1, 1], [Rational(1, 4), Rational(3, 4)])
+ # LOTS more
+
+
+@XFAIL
+def test_prudnikov_fail_other():
+ # 7.11.2
+
+ # 7.12.1
+ assert can_do([1, a], [b, 1 - 2*a + b]) # ???
+
+ # 7.14.2
+ assert can_do([Rational(-1, 2)], [S.Half, 1]) # struve
+ assert can_do([1], [S.Half, S.Half]) # struve
+ assert can_do([Rational(1, 4)], [S.Half, Rational(5, 4)]) # PFDD
+ assert can_do([Rational(3, 4)], [Rational(3, 2), Rational(7, 4)]) # PFDD
+ assert can_do([1], [Rational(1, 4), Rational(3, 4)]) # PFDD
+ assert can_do([1], [Rational(3, 4), Rational(5, 4)]) # PFDD
+ assert can_do([1], [Rational(5, 4), Rational(7, 4)]) # PFDD
+ # TODO LOTS more
+
+ # 7.15.2
+ assert can_do([S.Half, 1], [Rational(3, 4), Rational(5, 4), Rational(3, 2)]) # PFDD
+ assert can_do([S.Half, 1], [Rational(7, 4), Rational(5, 4), Rational(3, 2)]) # PFDD
+
+ # 7.16.1
+ assert can_do([], [Rational(1, 3), S(2/3)]) # PFDD
+ assert can_do([], [Rational(2, 3), S(4/3)]) # PFDD
+ assert can_do([], [Rational(5, 3), S(4/3)]) # PFDD
+
+ # XXX this does not *evaluate* right??
+ assert can_do([], [a, a + S.Half, 2*a - 1])
+
+
+def test_bug():
+ h = hyper([-1, 1], [z], -1)
+ assert hyperexpand(h) == (z + 1)/z
+
+
+def test_omgissue_203():
+ h = hyper((-5, -3, -4), (-6, -6), 1)
+ assert hyperexpand(h) == Rational(1, 30)
+ h = hyper((-6, -7, -5), (-6, -6), 1)
+ assert hyperexpand(h) == Rational(-1, 6)
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_powsimp.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_powsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..fdae6bfc1b26e560abdfca626b059a1ce77aa0a5
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_powsimp.py
@@ -0,0 +1,366 @@
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.numbers import (E, I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import sin
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.simplify.powsimp import (powdenest, powsimp)
+from sympy.simplify.simplify import (signsimp, simplify)
+from sympy.core.symbol import Str
+
+from sympy.abc import x, y, z, a, b
+
+
+def test_powsimp():
+ x, y, z, n = symbols('x,y,z,n')
+ f = Function('f')
+ assert powsimp( 4**x * 2**(-x) * 2**(-x) ) == 1
+ assert powsimp( (-4)**x * (-2)**(-x) * 2**(-x) ) == 1
+
+ assert powsimp(
+ f(4**x * 2**(-x) * 2**(-x)) ) == f(4**x * 2**(-x) * 2**(-x))
+ assert powsimp( f(4**x * 2**(-x) * 2**(-x)), deep=True ) == f(1)
+ assert exp(x)*exp(y) == exp(x)*exp(y)
+ assert powsimp(exp(x)*exp(y)) == exp(x + y)
+ assert powsimp(exp(x)*exp(y)*2**x*2**y) == (2*E)**(x + y)
+ assert powsimp(exp(x)*exp(y)*2**x*2**y, combine='exp') == \
+ exp(x + y)*2**(x + y)
+ assert powsimp(exp(x)*exp(y)*exp(2)*sin(x) + sin(y) + 2**x*2**y) == \
+ exp(2 + x + y)*sin(x) + sin(y) + 2**(x + y)
+ assert powsimp(sin(exp(x)*exp(y))) == sin(exp(x)*exp(y))
+ assert powsimp(sin(exp(x)*exp(y)), deep=True) == sin(exp(x + y))
+ assert powsimp(x**2*x**y) == x**(2 + y)
+ # This should remain factored, because 'exp' with deep=True is supposed
+ # to act like old automatic exponent combining.
+ assert powsimp((1 + E*exp(E))*exp(-E), combine='exp', deep=True) == \
+ (1 + exp(1 + E))*exp(-E)
+ assert powsimp((1 + E*exp(E))*exp(-E), deep=True) == \
+ (1 + exp(1 + E))*exp(-E)
+ assert powsimp((1 + E*exp(E))*exp(-E)) == (1 + exp(1 + E))*exp(-E)
+ assert powsimp((1 + E*exp(E))*exp(-E), combine='exp') == \
+ (1 + exp(1 + E))*exp(-E)
+ assert powsimp((1 + E*exp(E))*exp(-E), combine='base') == \
+ (1 + E*exp(E))*exp(-E)
+ x, y = symbols('x,y', nonnegative=True)
+ n = Symbol('n', real=True)
+ assert powsimp(y**n * (y/x)**(-n)) == x**n
+ assert powsimp(x**(x**(x*y)*y**(x*y))*y**(x**(x*y)*y**(x*y)), deep=True) \
+ == (x*y)**(x*y)**(x*y)
+ assert powsimp(2**(2**(2*x)*x), deep=False) == 2**(2**(2*x)*x)
+ assert powsimp(2**(2**(2*x)*x), deep=True) == 2**(x*4**x)
+ assert powsimp(
+ exp(-x + exp(-x)*exp(-x*log(x))), deep=False, combine='exp') == \
+ exp(-x + exp(-x)*exp(-x*log(x)))
+ assert powsimp(
+ exp(-x + exp(-x)*exp(-x*log(x))), deep=False, combine='exp') == \
+ exp(-x + exp(-x)*exp(-x*log(x)))
+ assert powsimp((x + y)/(3*z), deep=False, combine='exp') == (x + y)/(3*z)
+ assert powsimp((x/3 + y/3)/z, deep=True, combine='exp') == (x/3 + y/3)/z
+ assert powsimp(exp(x)/(1 + exp(x)*exp(y)), deep=True) == \
+ exp(x)/(1 + exp(x + y))
+ assert powsimp(x*y**(z**x*z**y), deep=True) == x*y**(z**(x + y))
+ assert powsimp((z**x*z**y)**x, deep=True) == (z**(x + y))**x
+ assert powsimp(x*(z**x*z**y)**x, deep=True) == x*(z**(x + y))**x
+ p = symbols('p', positive=True)
+ assert powsimp((1/x)**log(2)/x) == (1/x)**(1 + log(2))
+ assert powsimp((1/p)**log(2)/p) == p**(-1 - log(2))
+
+ # coefficient of exponent can only be simplified for positive bases
+ assert powsimp(2**(2*x)) == 4**x
+ assert powsimp((-1)**(2*x)) == (-1)**(2*x)
+ i = symbols('i', integer=True)
+ assert powsimp((-1)**(2*i)) == 1
+ assert powsimp((-1)**(-x)) != (-1)**x # could be 1/((-1)**x), but is not
+ # force=True overrides assumptions
+ assert powsimp((-1)**(2*x), force=True) == 1
+
+ # rational exponents allow combining of negative terms
+ w, n, m = symbols('w n m', negative=True)
+ e = i/a # not a rational exponent if `a` is unknown
+ ex = w**e*n**e*m**e
+ assert powsimp(ex) == m**(i/a)*n**(i/a)*w**(i/a)
+ e = i/3
+ ex = w**e*n**e*m**e
+ assert powsimp(ex) == (-1)**i*(-m*n*w)**(i/3)
+ e = (3 + i)/i
+ ex = w**e*n**e*m**e
+ assert powsimp(ex) == (-1)**(3*e)*(-m*n*w)**e
+
+ eq = x**(a*Rational(2, 3))
+ # eq != (x**a)**(2/3) (try x = -1 and a = 3 to see)
+ assert powsimp(eq).exp == eq.exp == a*Rational(2, 3)
+ # powdenest goes the other direction
+ assert powsimp(2**(2*x)) == 4**x
+
+ assert powsimp(exp(p/2)) == exp(p/2)
+
+ # issue 6368
+ eq = Mul(*[sqrt(Dummy(imaginary=True)) for i in range(3)])
+ assert powsimp(eq) == eq and eq.is_Mul
+
+ assert all(powsimp(e) == e for e in (sqrt(x**a), sqrt(x**2)))
+
+ # issue 8836
+ assert str( powsimp(exp(I*pi/3)*root(-1,3)) ) == '(-1)**(2/3)'
+
+ # issue 9183
+ assert powsimp(-0.1**x) == -0.1**x
+
+ # issue 10095
+ assert powsimp((1/(2*E))**oo) == (exp(-1)/2)**oo
+
+ # PR 13131
+ eq = sin(2*x)**2*sin(2.0*x)**2
+ assert powsimp(eq) == eq
+
+ # issue 14615
+ assert powsimp(x**2*y**3*(x*y**2)**Rational(3, 2)
+ ) == x*y*(x*y**2)**Rational(5, 2)
+
+
+def test_powsimp_negated_base():
+ assert powsimp((-x + y)/sqrt(x - y)) == -sqrt(x - y)
+ assert powsimp((-x + y)*(-z + y)/sqrt(x - y)/sqrt(z - y)) == sqrt(x - y)*sqrt(z - y)
+ p = symbols('p', positive=True)
+ reps = {p: 2, a: S.Half}
+ assert powsimp((-p)**a/p**a).subs(reps) == ((-1)**a).subs(reps)
+ assert powsimp((-p)**a*p**a).subs(reps) == ((-p**2)**a).subs(reps)
+ n = symbols('n', negative=True)
+ reps = {p: -2, a: S.Half}
+ assert powsimp((-n)**a/n**a).subs(reps) == (-1)**(-a).subs(a, S.Half)
+ assert powsimp((-n)**a*n**a).subs(reps) == ((-n**2)**a).subs(reps)
+ # if x is 0 then the lhs is 0**a*oo**a which is not (-1)**a
+ eq = (-x)**a/x**a
+ assert powsimp(eq) == eq
+
+
+def test_powsimp_nc():
+ x, y, z = symbols('x,y,z')
+ A, B, C = symbols('A B C', commutative=False)
+
+ assert powsimp(A**x*A**y, combine='all') == A**(x + y)
+ assert powsimp(A**x*A**y, combine='base') == A**x*A**y
+ assert powsimp(A**x*A**y, combine='exp') == A**(x + y)
+
+ assert powsimp(A**x*B**x, combine='all') == A**x*B**x
+ assert powsimp(A**x*B**x, combine='base') == A**x*B**x
+ assert powsimp(A**x*B**x, combine='exp') == A**x*B**x
+
+ assert powsimp(B**x*A**x, combine='all') == B**x*A**x
+ assert powsimp(B**x*A**x, combine='base') == B**x*A**x
+ assert powsimp(B**x*A**x, combine='exp') == B**x*A**x
+
+ assert powsimp(A**x*A**y*A**z, combine='all') == A**(x + y + z)
+ assert powsimp(A**x*A**y*A**z, combine='base') == A**x*A**y*A**z
+ assert powsimp(A**x*A**y*A**z, combine='exp') == A**(x + y + z)
+
+ assert powsimp(A**x*B**x*C**x, combine='all') == A**x*B**x*C**x
+ assert powsimp(A**x*B**x*C**x, combine='base') == A**x*B**x*C**x
+ assert powsimp(A**x*B**x*C**x, combine='exp') == A**x*B**x*C**x
+
+ assert powsimp(B**x*A**x*C**x, combine='all') == B**x*A**x*C**x
+ assert powsimp(B**x*A**x*C**x, combine='base') == B**x*A**x*C**x
+ assert powsimp(B**x*A**x*C**x, combine='exp') == B**x*A**x*C**x
+
+
+def test_issue_6440():
+ assert powsimp(16*2**a*8**b) == 2**(a + 3*b + 4)
+
+
+def test_powdenest():
+ x, y = symbols('x,y')
+ p, q = symbols('p q', positive=True)
+ i, j = symbols('i,j', integer=True)
+
+ assert powdenest(x) == x
+ assert powdenest(x + 2*(x**(a*Rational(2, 3)))**(3*x)) == (x + 2*(x**(a*Rational(2, 3)))**(3*x))
+ assert powdenest((exp(a*Rational(2, 3)))**(3*x)) # -X-> (exp(a/3))**(6*x)
+ assert powdenest((x**(a*Rational(2, 3)))**(3*x)) == ((x**(a*Rational(2, 3)))**(3*x))
+ assert powdenest(exp(3*x*log(2))) == 2**(3*x)
+ assert powdenest(sqrt(p**2)) == p
+ eq = p**(2*i)*q**(4*i)
+ assert powdenest(eq) == (p*q**2)**(2*i)
+ # -X-> (x**x)**i*(x**x)**j == x**(x*(i + j))
+ assert powdenest((x**x)**(i + j))
+ assert powdenest(exp(3*y*log(x))) == x**(3*y)
+ assert powdenest(exp(y*(log(a) + log(b)))) == (a*b)**y
+ assert powdenest(exp(3*(log(a) + log(b)))) == a**3*b**3
+ assert powdenest(((x**(2*i))**(3*y))**x) == ((x**(2*i))**(3*y))**x
+ assert powdenest(((x**(2*i))**(3*y))**x, force=True) == x**(6*i*x*y)
+ assert powdenest(((x**(a*Rational(2, 3)))**(3*y/i))**x) == \
+ (((x**(a*Rational(2, 3)))**(3*y/i))**x)
+ assert powdenest((x**(2*i)*y**(4*i))**z, force=True) == (x*y**2)**(2*i*z)
+ assert powdenest((p**(2*i)*q**(4*i))**j) == (p*q**2)**(2*i*j)
+ e = ((p**(2*a))**(3*y))**x
+ assert powdenest(e) == e
+ e = ((x**2*y**4)**a)**(x*y)
+ assert powdenest(e) == e
+ e = (((x**2*y**4)**a)**(x*y))**3
+ assert powdenest(e) == ((x**2*y**4)**a)**(3*x*y)
+ assert powdenest((((x**2*y**4)**a)**(x*y)), force=True) == \
+ (x*y**2)**(2*a*x*y)
+ assert powdenest((((x**2*y**4)**a)**(x*y))**3, force=True) == \
+ (x*y**2)**(6*a*x*y)
+ assert powdenest((x**2*y**6)**i) != (x*y**3)**(2*i)
+ x, y = symbols('x,y', positive=True)
+ assert powdenest((x**2*y**6)**i) == (x*y**3)**(2*i)
+
+ assert powdenest((x**(i*Rational(2, 3))*y**(i/2))**(2*i)) == (x**Rational(4, 3)*y)**(i**2)
+ assert powdenest(sqrt(x**(2*i)*y**(6*i))) == (x*y**3)**i
+
+ assert powdenest(4**x) == 2**(2*x)
+ assert powdenest((4**x)**y) == 2**(2*x*y)
+ assert powdenest(4**x*y) == 2**(2*x)*y
+
+
+def test_powdenest_polar():
+ x, y, z = symbols('x y z', polar=True)
+ a, b, c = symbols('a b c')
+ assert powdenest((x*y*z)**a) == x**a*y**a*z**a
+ assert powdenest((x**a*y**b)**c) == x**(a*c)*y**(b*c)
+ assert powdenest(((x**a)**b*y**c)**c) == x**(a*b*c)*y**(c**2)
+
+
+def test_issue_5805():
+ arg = ((gamma(x)*hyper((), (), x))*pi)**2
+ assert powdenest(arg) == (pi*gamma(x)*hyper((), (), x))**2
+ assert arg.is_positive is None
+
+
+def test_issue_9324_powsimp_on_matrix_symbol():
+ M = MatrixSymbol('M', 10, 10)
+ expr = powsimp(M, deep=True)
+ assert expr == M
+ assert expr.args[0] == Str('M')
+
+
+def test_issue_6367():
+ z = -5*sqrt(2)/(2*sqrt(2*sqrt(29) + 29)) + sqrt(-sqrt(29)/29 + S.Half)
+ assert Mul(*[powsimp(a) for a in Mul.make_args(z.normal())]) == 0
+ assert powsimp(z.normal()) == 0
+ assert simplify(z) == 0
+ assert powsimp(sqrt(2 + sqrt(3))*sqrt(2 - sqrt(3)) + 1) == 2
+ assert powsimp(z) != 0
+
+
+def test_powsimp_polar():
+ from sympy.functions.elementary.complexes import polar_lift
+ from sympy.functions.elementary.exponential import exp_polar
+ x, y, z = symbols('x y z')
+ p, q, r = symbols('p q r', polar=True)
+
+ assert (polar_lift(-1))**(2*x) == exp_polar(2*pi*I*x)
+ assert powsimp(p**x * q**x) == (p*q)**x
+ assert p**x * (1/p)**x == 1
+ assert (1/p)**x == p**(-x)
+
+ assert exp_polar(x)*exp_polar(y) == exp_polar(x)*exp_polar(y)
+ assert powsimp(exp_polar(x)*exp_polar(y)) == exp_polar(x + y)
+ assert powsimp(exp_polar(x)*exp_polar(y)*p**x*p**y) == \
+ (p*exp_polar(1))**(x + y)
+ assert powsimp(exp_polar(x)*exp_polar(y)*p**x*p**y, combine='exp') == \
+ exp_polar(x + y)*p**(x + y)
+ assert powsimp(
+ exp_polar(x)*exp_polar(y)*exp_polar(2)*sin(x) + sin(y) + p**x*p**y) \
+ == p**(x + y) + sin(x)*exp_polar(2 + x + y) + sin(y)
+ assert powsimp(sin(exp_polar(x)*exp_polar(y))) == \
+ sin(exp_polar(x)*exp_polar(y))
+ assert powsimp(sin(exp_polar(x)*exp_polar(y)), deep=True) == \
+ sin(exp_polar(x + y))
+
+
+def test_issue_5728():
+ b = x*sqrt(y)
+ a = sqrt(b)
+ c = sqrt(sqrt(x)*y)
+ assert powsimp(a*b) == sqrt(b)**3
+ assert powsimp(a*b**2*sqrt(y)) == sqrt(y)*a**5
+ assert powsimp(a*x**2*c**3*y) == c**3*a**5
+ assert powsimp(a*x*c**3*y**2) == c**7*a
+ assert powsimp(x*c**3*y**2) == c**7
+ assert powsimp(x*c**3*y) == x*y*c**3
+ assert powsimp(sqrt(x)*c**3*y) == c**5
+ assert powsimp(sqrt(x)*a**3*sqrt(y)) == sqrt(x)*sqrt(y)*a**3
+ assert powsimp(Mul(sqrt(x)*c**3*sqrt(y), y, evaluate=False)) == \
+ sqrt(x)*sqrt(y)**3*c**3
+ assert powsimp(a**2*a*x**2*y) == a**7
+
+ # symbolic powers work, too
+ b = x**y*y
+ a = b*sqrt(b)
+ assert a.is_Mul is True
+ assert powsimp(a) == sqrt(b)**3
+
+ # as does exp
+ a = x*exp(y*Rational(2, 3))
+ assert powsimp(a*sqrt(a)) == sqrt(a)**3
+ assert powsimp(a**2*sqrt(a)) == sqrt(a)**5
+ assert powsimp(a**2*sqrt(sqrt(a))) == sqrt(sqrt(a))**9
+
+
+def test_issue_from_PR1599():
+ n1, n2, n3, n4 = symbols('n1 n2 n3 n4', negative=True)
+ assert (powsimp(sqrt(n1)*sqrt(n2)*sqrt(n3)) ==
+ -I*sqrt(-n1)*sqrt(-n2)*sqrt(-n3))
+ assert (powsimp(root(n1, 3)*root(n2, 3)*root(n3, 3)*root(n4, 3)) ==
+ -(-1)**Rational(1, 3)*
+ (-n1)**Rational(1, 3)*(-n2)**Rational(1, 3)*(-n3)**Rational(1, 3)*(-n4)**Rational(1, 3))
+
+
+def test_issue_10195():
+ a = Symbol('a', integer=True)
+ l = Symbol('l', even=True, nonzero=True)
+ n = Symbol('n', odd=True)
+ e_x = (-1)**(n/2 - S.Half) - (-1)**(n*Rational(3, 2) - S.Half)
+ assert powsimp((-1)**(l/2)) == I**l
+ assert powsimp((-1)**(n/2)) == I**n
+ assert powsimp((-1)**(n*Rational(3, 2))) == -I**n
+ assert powsimp(e_x) == (-1)**(n/2 - S.Half) + (-1)**(n*Rational(3, 2) +
+ S.Half)
+ assert powsimp((-1)**(a*Rational(3, 2))) == (-I)**a
+
+def test_issue_15709():
+ assert powsimp(3**x*Rational(2, 3)) == 2*3**(x-1)
+ assert powsimp(2*3**x/3) == 2*3**(x-1)
+
+
+def test_issue_11981():
+ x, y = symbols('x y', commutative=False)
+ assert powsimp((x*y)**2 * (y*x)**2) == (x*y)**2 * (y*x)**2
+
+
+def test_issue_17524():
+ a = symbols("a", real=True)
+ e = (-1 - a**2)*sqrt(1 + a**2)
+ assert signsimp(powsimp(e)) == signsimp(e) == -(a**2 + 1)**(S(3)/2)
+
+
+def test_issue_19627():
+ # if you use force the user must verify
+ assert powdenest(sqrt(sin(x)**2), force=True) == sin(x)
+ assert powdenest((x**(S.Half/y))**(2*y), force=True) == x
+ from sympy.core.function import expand_power_base
+ e = 1 - a
+ expr = (exp(z/e)*x**(b/e)*y**((1 - b)/e))**e
+ assert powdenest(expand_power_base(expr, force=True), force=True
+ ) == x**b*y**(1 - b)*exp(z)
+
+
+def test_issue_22546():
+ p1, p2 = symbols('p1, p2', positive=True)
+ ref = powsimp(p1**z/p2**z)
+ e = z + 1
+ ans = ref.subs(z, e)
+ assert ans.is_Pow
+ assert powsimp(p1**e/p2**e) == ans
+ i = symbols('i', integer=True)
+ ref = powsimp(x**i/y**i)
+ e = i + 1
+ ans = ref.subs(i, e)
+ assert ans.is_Pow
+ assert powsimp(x**e/y**e) == ans
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_radsimp.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_radsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..fabea1f1acb63c1e7845e82bcfd2a41c6bf97e67
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_radsimp.py
@@ -0,0 +1,490 @@
+from sympy.core.add import Add
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, Wild, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.polys.polytools import factor
+from sympy.series.order import O
+from sympy.simplify.radsimp import (collect, collect_const, fraction, radsimp, rcollect)
+
+from sympy.core.expr import unchanged
+from sympy.core.mul import _unevaluated_Mul as umul
+from sympy.simplify.radsimp import (_unevaluated_Add,
+ collect_sqrt, fraction_expand, collect_abs)
+from sympy.testing.pytest import raises
+
+from sympy.abc import x, y, z, a, b, c, d
+
+
+def test_radsimp():
+ r2 = sqrt(2)
+ r3 = sqrt(3)
+ r5 = sqrt(5)
+ r7 = sqrt(7)
+ assert fraction(radsimp(1/r2)) == (sqrt(2), 2)
+ assert radsimp(1/(1 + r2)) == \
+ -1 + sqrt(2)
+ assert radsimp(1/(r2 + r3)) == \
+ -sqrt(2) + sqrt(3)
+ assert fraction(radsimp(1/(1 + r2 + r3))) == \
+ (-sqrt(6) + sqrt(2) + 2, 4)
+ assert fraction(radsimp(1/(r2 + r3 + r5))) == \
+ (-sqrt(30) + 2*sqrt(3) + 3*sqrt(2), 12)
+ assert fraction(radsimp(1/(1 + r2 + r3 + r5))) == (
+ (-34*sqrt(10) - 26*sqrt(15) - 55*sqrt(3) - 61*sqrt(2) + 14*sqrt(30) +
+ 93 + 46*sqrt(6) + 53*sqrt(5), 71))
+ assert fraction(radsimp(1/(r2 + r3 + r5 + r7))) == (
+ (-50*sqrt(42) - 133*sqrt(5) - 34*sqrt(70) - 145*sqrt(3) + 22*sqrt(105)
+ + 185*sqrt(2) + 62*sqrt(30) + 135*sqrt(7), 215))
+ z = radsimp(1/(1 + r2/3 + r3/5 + r5 + r7))
+ assert len((3616791619821680643598*z).args) == 16
+ assert radsimp(1/z) == 1/z
+ assert radsimp(1/z, max_terms=20).expand() == 1 + r2/3 + r3/5 + r5 + r7
+ assert radsimp(1/(r2*3)) == \
+ sqrt(2)/6
+ assert radsimp(1/(r2*a + r3 + r5 + r7)) == (
+ (8*sqrt(2)*a**7 - 8*sqrt(7)*a**6 - 8*sqrt(5)*a**6 - 8*sqrt(3)*a**6 -
+ 180*sqrt(2)*a**5 + 8*sqrt(30)*a**5 + 8*sqrt(42)*a**5 + 8*sqrt(70)*a**5
+ - 24*sqrt(105)*a**4 + 84*sqrt(3)*a**4 + 100*sqrt(5)*a**4 +
+ 116*sqrt(7)*a**4 - 72*sqrt(70)*a**3 - 40*sqrt(42)*a**3 -
+ 8*sqrt(30)*a**3 + 782*sqrt(2)*a**3 - 462*sqrt(3)*a**2 -
+ 302*sqrt(7)*a**2 - 254*sqrt(5)*a**2 + 120*sqrt(105)*a**2 -
+ 795*sqrt(2)*a - 62*sqrt(30)*a + 82*sqrt(42)*a + 98*sqrt(70)*a -
+ 118*sqrt(105) + 59*sqrt(7) + 295*sqrt(5) + 531*sqrt(3))/(16*a**8 -
+ 480*a**6 + 3128*a**4 - 6360*a**2 + 3481))
+ assert radsimp(1/(r2*a + r2*b + r3 + r7)) == (
+ (sqrt(2)*a*(a + b)**2 - 5*sqrt(2)*a + sqrt(42)*a + sqrt(2)*b*(a +
+ b)**2 - 5*sqrt(2)*b + sqrt(42)*b - sqrt(7)*(a + b)**2 - sqrt(3)*(a +
+ b)**2 - 2*sqrt(3) + 2*sqrt(7))/(2*a**4 + 8*a**3*b + 12*a**2*b**2 -
+ 20*a**2 + 8*a*b**3 - 40*a*b + 2*b**4 - 20*b**2 + 8))
+ assert radsimp(1/(r2*a + r2*b + r2*c + r2*d)) == \
+ sqrt(2)/(2*a + 2*b + 2*c + 2*d)
+ assert radsimp(1/(1 + r2*a + r2*b + r2*c + r2*d)) == (
+ (sqrt(2)*a + sqrt(2)*b + sqrt(2)*c + sqrt(2)*d - 1)/(2*a**2 + 4*a*b +
+ 4*a*c + 4*a*d + 2*b**2 + 4*b*c + 4*b*d + 2*c**2 + 4*c*d + 2*d**2 - 1))
+ assert radsimp((y**2 - x)/(y - sqrt(x))) == \
+ sqrt(x) + y
+ assert radsimp(-(y**2 - x)/(y - sqrt(x))) == \
+ -(sqrt(x) + y)
+ assert radsimp(1/(1 - I + a*I)) == \
+ (-I*a + 1 + I)/(a**2 - 2*a + 2)
+ assert radsimp(1/((-x + y)*(x - sqrt(y)))) == \
+ (-x - sqrt(y))/((x - y)*(x**2 - y))
+ e = (3 + 3*sqrt(2))*x*(3*x - 3*sqrt(y))
+ assert radsimp(e) == x*(3 + 3*sqrt(2))*(3*x - 3*sqrt(y))
+ assert radsimp(1/e) == (
+ (-9*x + 9*sqrt(2)*x - 9*sqrt(y) + 9*sqrt(2)*sqrt(y))/(9*x*(9*x**2 -
+ 9*y)))
+ assert radsimp(1 + 1/(1 + sqrt(3))) == \
+ Mul(S.Half, -1 + sqrt(3), evaluate=False) + 1
+ A = symbols("A", commutative=False)
+ assert radsimp(x**2 + sqrt(2)*x**2 - sqrt(2)*x*A) == \
+ x**2 + sqrt(2)*x**2 - sqrt(2)*x*A
+ assert radsimp(1/sqrt(5 + 2 * sqrt(6))) == -sqrt(2) + sqrt(3)
+ assert radsimp(1/sqrt(5 + 2 * sqrt(6))**3) == -(-sqrt(3) + sqrt(2))**3
+
+ # issue 6532
+ assert fraction(radsimp(1/sqrt(x))) == (sqrt(x), x)
+ assert fraction(radsimp(1/sqrt(2*x + 3))) == (sqrt(2*x + 3), 2*x + 3)
+ assert fraction(radsimp(1/sqrt(2*(x + 3)))) == (sqrt(2*x + 6), 2*x + 6)
+
+ # issue 5994
+ e = S('-(2 + 2*sqrt(2) + 4*2**(1/4))/'
+ '(1 + 2**(3/4) + 3*2**(1/4) + 3*sqrt(2))')
+ assert radsimp(e).expand() == -2*2**Rational(3, 4) - 2*2**Rational(1, 4) + 2 + 2*sqrt(2)
+
+ # issue 5986 (modifications to radimp didn't initially recognize this so
+ # the test is included here)
+ assert radsimp(1/(-sqrt(5)/2 - S.Half + (-sqrt(5)/2 - S.Half)**2)) == 1
+
+ # from issue 5934
+ eq = (
+ (-240*sqrt(2)*sqrt(sqrt(5) + 5)*sqrt(8*sqrt(5) + 40) -
+ 360*sqrt(2)*sqrt(-8*sqrt(5) + 40)*sqrt(-sqrt(5) + 5) -
+ 120*sqrt(10)*sqrt(-8*sqrt(5) + 40)*sqrt(-sqrt(5) + 5) +
+ 120*sqrt(2)*sqrt(-sqrt(5) + 5)*sqrt(8*sqrt(5) + 40) +
+ 120*sqrt(2)*sqrt(-8*sqrt(5) + 40)*sqrt(sqrt(5) + 5) +
+ 120*sqrt(10)*sqrt(-sqrt(5) + 5)*sqrt(8*sqrt(5) + 40) +
+ 120*sqrt(10)*sqrt(-8*sqrt(5) + 40)*sqrt(sqrt(5) + 5))/(-36000 -
+ 7200*sqrt(5) + (12*sqrt(10)*sqrt(sqrt(5) + 5) +
+ 24*sqrt(10)*sqrt(-sqrt(5) + 5))**2))
+ assert radsimp(eq) is S.NaN # it's 0/0
+
+ # work with normal form
+ e = 1/sqrt(sqrt(7)/7 + 2*sqrt(2) + 3*sqrt(3) + 5*sqrt(5)) + 3
+ assert radsimp(e) == (
+ -sqrt(sqrt(7) + 14*sqrt(2) + 21*sqrt(3) +
+ 35*sqrt(5))*(-11654899*sqrt(35) - 1577436*sqrt(210) - 1278438*sqrt(15)
+ - 1346996*sqrt(10) + 1635060*sqrt(6) + 5709765 + 7539830*sqrt(14) +
+ 8291415*sqrt(21))/1300423175 + 3)
+
+ # obey power rules
+ base = sqrt(3) - sqrt(2)
+ assert radsimp(1/base**3) == (sqrt(3) + sqrt(2))**3
+ assert radsimp(1/(-base)**3) == -(sqrt(2) + sqrt(3))**3
+ assert radsimp(1/(-base)**x) == (-base)**(-x)
+ assert radsimp(1/base**x) == (sqrt(2) + sqrt(3))**x
+ assert radsimp(root(1/(-1 - sqrt(2)), -x)) == (-1)**(-1/x)*(1 + sqrt(2))**(1/x)
+
+ # recurse
+ e = cos(1/(1 + sqrt(2)))
+ assert radsimp(e) == cos(-sqrt(2) + 1)
+ assert radsimp(e/2) == cos(-sqrt(2) + 1)/2
+ assert radsimp(1/e) == 1/cos(-sqrt(2) + 1)
+ assert radsimp(2/e) == 2/cos(-sqrt(2) + 1)
+ assert fraction(radsimp(e/sqrt(x))) == (sqrt(x)*cos(-sqrt(2)+1), x)
+
+ # test that symbolic denominators are not processed
+ r = 1 + sqrt(2)
+ assert radsimp(x/r, symbolic=False) == -x*(-sqrt(2) + 1)
+ assert radsimp(x/(y + r), symbolic=False) == x/(y + 1 + sqrt(2))
+ assert radsimp(x/(y + r)/r, symbolic=False) == \
+ -x*(-sqrt(2) + 1)/(y + 1 + sqrt(2))
+
+ # issue 7408
+ eq = sqrt(x)/sqrt(y)
+ assert radsimp(eq) == umul(sqrt(x), sqrt(y), 1/y)
+ assert radsimp(eq, symbolic=False) == eq
+
+ # issue 7498
+ assert radsimp(sqrt(x)/sqrt(y)**3) == umul(sqrt(x), sqrt(y**3), 1/y**3)
+
+ # for coverage
+ eq = sqrt(x)/y**2
+ assert radsimp(eq) == eq
+
+
+def test_radsimp_issue_3214():
+ c, p = symbols('c p', positive=True)
+ s = sqrt(c**2 - p**2)
+ b = (c + I*p - s)/(c + I*p + s)
+ assert radsimp(b) == -I*(c + I*p - sqrt(c**2 - p**2))**2/(2*c*p)
+
+
+def test_collect_1():
+ """Collect with respect to Symbol"""
+ x, y, z, n = symbols('x,y,z,n')
+ assert collect(1, x) == 1
+ assert collect( x + y*x, x ) == x * (1 + y)
+ assert collect( x + x**2, x ) == x + x**2
+ assert collect( x**2 + y*x**2, x ) == (x**2)*(1 + y)
+ assert collect( x**2 + y*x, x ) == x*y + x**2
+ assert collect( 2*x**2 + y*x**2 + 3*x*y, [x] ) == x**2*(2 + y) + 3*x*y
+ assert collect( 2*x**2 + y*x**2 + 3*x*y, [y] ) == 2*x**2 + y*(x**2 + 3*x)
+
+ assert collect( ((1 + y + x)**4).expand(), x) == ((1 + y)**4).expand() + \
+ x*(4*(1 + y)**3).expand() + x**2*(6*(1 + y)**2).expand() + \
+ x**3*(4*(1 + y)).expand() + x**4
+ # symbols can be given as any iterable
+ expr = x + y
+ assert collect(expr, expr.free_symbols) == expr
+ assert collect(x*exp(x) + sin(x)*y + sin(x)*2 + 3*x, x, exact=None
+ ) == x*exp(x) + 3*x + (y + 2)*sin(x)
+ assert collect(x*exp(x) + sin(x)*y + sin(x)*2 + 3*x + y*x +
+ y*x*exp(x), x, exact=None
+ ) == x*exp(x)*(y + 1) + (3 + y)*x + (y + 2)*sin(x)
+
+
+def test_collect_2():
+ """Collect with respect to a sum"""
+ a, b, x = symbols('a,b,x')
+ assert collect(a*(cos(x) + sin(x)) + b*(cos(x) + sin(x)),
+ sin(x) + cos(x)) == (a + b)*(cos(x) + sin(x))
+
+
+def test_collect_3():
+ """Collect with respect to a product"""
+ a, b, c = symbols('a,b,c')
+ f = Function('f')
+ x, y, z, n = symbols('x,y,z,n')
+
+ assert collect(-x/8 + x*y, -x) == x*(y - Rational(1, 8))
+
+ assert collect( 1 + x*(y**2), x*y ) == 1 + x*(y**2)
+ assert collect( x*y + a*x*y, x*y) == x*y*(1 + a)
+ assert collect( 1 + x*y + a*x*y, x*y) == 1 + x*y*(1 + a)
+ assert collect(a*x*f(x) + b*(x*f(x)), x*f(x)) == x*(a + b)*f(x)
+
+ assert collect(a*x*log(x) + b*(x*log(x)), x*log(x)) == x*(a + b)*log(x)
+ assert collect(a*x**2*log(x)**2 + b*(x*log(x))**2, x*log(x)) == \
+ x**2*log(x)**2*(a + b)
+
+ # with respect to a product of three symbols
+ assert collect(y*x*z + a*x*y*z, x*y*z) == (1 + a)*x*y*z
+
+
+def test_collect_4():
+ """Collect with respect to a power"""
+ a, b, c, x = symbols('a,b,c,x')
+
+ assert collect(a*x**c + b*x**c, x**c) == x**c*(a + b)
+ # issue 6096: 2 stays with c (unless c is integer or x is positive0
+ assert collect(a*x**(2*c) + b*x**(2*c), x**c) == x**(2*c)*(a + b)
+
+
+def test_collect_5():
+ """Collect with respect to a tuple"""
+ a, x, y, z, n = symbols('a,x,y,z,n')
+ assert collect(x**2*y**4 + z*(x*y**2)**2 + z + a*z, [x*y**2, z]) in [
+ z*(1 + a + x**2*y**4) + x**2*y**4,
+ z*(1 + a) + x**2*y**4*(1 + z) ]
+ assert collect((1 + (x + y) + (x + y)**2).expand(),
+ [x, y]) == 1 + y + x*(1 + 2*y) + x**2 + y**2
+
+
+def test_collect_pr19431():
+ """Unevaluated collect with respect to a product"""
+ a = symbols('a')
+ assert collect(a**2*(a**2 + 1), a**2, evaluate=False)[a**2] == (a**2 + 1)
+
+
+def test_collect_D():
+ D = Derivative
+ f = Function('f')
+ x, a, b = symbols('x,a,b')
+ fx = D(f(x), x)
+ fxx = D(f(x), x, x)
+
+ assert collect(a*fx + b*fx, fx) == (a + b)*fx
+ assert collect(a*D(fx, x) + b*D(fx, x), fx) == (a + b)*D(fx, x)
+ assert collect(a*fxx + b*fxx, fx) == (a + b)*D(fx, x)
+ # issue 4784
+ assert collect(5*f(x) + 3*fx, fx) == 5*f(x) + 3*fx
+ assert collect(f(x) + f(x)*diff(f(x), x) + x*diff(f(x), x)*f(x), f(x).diff(x)) == \
+ (x*f(x) + f(x))*D(f(x), x) + f(x)
+ assert collect(f(x) + f(x)*diff(f(x), x) + x*diff(f(x), x)*f(x), f(x).diff(x), exact=True) == \
+ (x*f(x) + f(x))*D(f(x), x) + f(x)
+ assert collect(1/f(x) + 1/f(x)*diff(f(x), x) + x*diff(f(x), x)/f(x), f(x).diff(x), exact=True) == \
+ (1/f(x) + x/f(x))*D(f(x), x) + 1/f(x)
+ e = (1 + x*fx + fx)/f(x)
+ assert collect(e.expand(), fx) == fx*(x/f(x) + 1/f(x)) + 1/f(x)
+
+
+def test_collect_func():
+ f = ((x + a + 1)**3).expand()
+
+ assert collect(f, x) == a**3 + 3*a**2 + 3*a + x**3 + x**2*(3*a + 3) + \
+ x*(3*a**2 + 6*a + 3) + 1
+ assert collect(f, x, factor) == x**3 + 3*x**2*(a + 1) + 3*x*(a + 1)**2 + \
+ (a + 1)**3
+
+ assert collect(f, x, evaluate=False) == {
+ S.One: a**3 + 3*a**2 + 3*a + 1,
+ x: 3*a**2 + 6*a + 3, x**2: 3*a + 3,
+ x**3: 1
+ }
+
+ assert collect(f, x, factor, evaluate=False) == {
+ S.One: (a + 1)**3, x: 3*(a + 1)**2,
+ x**2: umul(S(3), a + 1), x**3: 1}
+
+
+def test_collect_order():
+ a, b, x, t = symbols('a,b,x,t')
+
+ assert collect(t + t*x + t*x**2 + O(x**3), t) == t*(1 + x + x**2 + O(x**3))
+ assert collect(t + t*x + x**2 + O(x**3), t) == \
+ t*(1 + x + O(x**3)) + x**2 + O(x**3)
+
+ f = a*x + b*x + c*x**2 + d*x**2 + O(x**3)
+ g = x*(a + b) + x**2*(c + d) + O(x**3)
+
+ assert collect(f, x) == g
+ assert collect(f, x, distribute_order_term=False) == g
+
+ f = sin(a + b).series(b, 0, 10)
+
+ assert collect(f, [sin(a), cos(a)]) == \
+ sin(a)*cos(b).series(b, 0, 10) + cos(a)*sin(b).series(b, 0, 10)
+ assert collect(f, [sin(a), cos(a)], distribute_order_term=False) == \
+ sin(a)*cos(b).series(b, 0, 10).removeO() + \
+ cos(a)*sin(b).series(b, 0, 10).removeO() + O(b**10)
+
+
+def test_rcollect():
+ assert rcollect((x**2*y + x*y + x + y)/(x + y), y) == \
+ (x + y*(1 + x + x**2))/(x + y)
+ assert rcollect(sqrt(-((x + 1)*(y + 1))), z) == sqrt(-((x + 1)*(y + 1)))
+
+
+def test_collect_D_0():
+ D = Derivative
+ f = Function('f')
+ x, a, b = symbols('x,a,b')
+ fxx = D(f(x), x, x)
+
+ assert collect(a*fxx + b*fxx, fxx) == (a + b)*fxx
+
+
+def test_collect_Wild():
+ """Collect with respect to functions with Wild argument"""
+ a, b, x, y = symbols('a b x y')
+ f = Function('f')
+ w1 = Wild('.1')
+ w2 = Wild('.2')
+ assert collect(f(x) + a*f(x), f(w1)) == (1 + a)*f(x)
+ assert collect(f(x, y) + a*f(x, y), f(w1)) == f(x, y) + a*f(x, y)
+ assert collect(f(x, y) + a*f(x, y), f(w1, w2)) == (1 + a)*f(x, y)
+ assert collect(f(x, y) + a*f(x, y), f(w1, w1)) == f(x, y) + a*f(x, y)
+ assert collect(f(x, x) + a*f(x, x), f(w1, w1)) == (1 + a)*f(x, x)
+ assert collect(a*(x + 1)**y + (x + 1)**y, w1**y) == (1 + a)*(x + 1)**y
+ assert collect(a*(x + 1)**y + (x + 1)**y, w1**b) == \
+ a*(x + 1)**y + (x + 1)**y
+ assert collect(a*(x + 1)**y + (x + 1)**y, (x + 1)**w2) == \
+ (1 + a)*(x + 1)**y
+ assert collect(a*(x + 1)**y + (x + 1)**y, w1**w2) == (1 + a)*(x + 1)**y
+
+
+def test_collect_const():
+ # coverage not provided by above tests
+ assert collect_const(2*sqrt(3) + 4*a*sqrt(5)) == \
+ 2*(2*sqrt(5)*a + sqrt(3)) # let the primitive reabsorb
+ assert collect_const(2*sqrt(3) + 4*a*sqrt(5), sqrt(3)) == \
+ 2*sqrt(3) + 4*a*sqrt(5)
+ assert collect_const(sqrt(2)*(1 + sqrt(2)) + sqrt(3) + x*sqrt(2)) == \
+ sqrt(2)*(x + 1 + sqrt(2)) + sqrt(3)
+
+ # issue 5290
+ assert collect_const(2*x + 2*y + 1, 2) == \
+ collect_const(2*x + 2*y + 1) == \
+ Add(S.One, Mul(2, x + y, evaluate=False), evaluate=False)
+ assert collect_const(-y - z) == Mul(-1, y + z, evaluate=False)
+ assert collect_const(2*x - 2*y - 2*z, 2) == \
+ Mul(2, x - y - z, evaluate=False)
+ assert collect_const(2*x - 2*y - 2*z, -2) == \
+ _unevaluated_Add(2*x, Mul(-2, y + z, evaluate=False))
+
+ # this is why the content_primitive is used
+ eq = (sqrt(15 + 5*sqrt(2))*x + sqrt(3 + sqrt(2))*y)*2
+ assert collect_sqrt(eq + 2) == \
+ 2*sqrt(sqrt(2) + 3)*(sqrt(5)*x + y) + 2
+
+ # issue 16296
+ assert collect_const(a + b + x/2 + y/2) == a + b + Mul(S.Half, x + y, evaluate=False)
+
+
+def test_issue_13143():
+ f = Function('f')
+ fx = f(x).diff(x)
+ e = f(x) + fx + f(x)*fx
+ # collect function before derivative
+ assert collect(e, Wild('w')) == f(x)*(fx + 1) + fx
+ e = f(x) + f(x)*fx + x*fx*f(x)
+ assert collect(e, fx) == (x*f(x) + f(x))*fx + f(x)
+ assert collect(e, f(x)) == (x*fx + fx + 1)*f(x)
+ e = f(x) + fx + f(x)*fx
+ assert collect(e, [f(x), fx]) == f(x)*(1 + fx) + fx
+ assert collect(e, [fx, f(x)]) == fx*(1 + f(x)) + f(x)
+
+
+def test_issue_6097():
+ assert collect(a*y**(2.0*x) + b*y**(2.0*x), y**x) == (a + b)*(y**x)**2.0
+ assert collect(a*2**(2.0*x) + b*2**(2.0*x), 2**x) == (a + b)*(2**x)**2.0
+
+
+def test_fraction_expand():
+ eq = (x + y)*y/x
+ assert eq.expand(frac=True) == fraction_expand(eq) == (x*y + y**2)/x
+ assert eq.expand() == y + y**2/x
+
+
+def test_fraction():
+ x, y, z = map(Symbol, 'xyz')
+ A = Symbol('A', commutative=False)
+
+ assert fraction(S.Half) == (1, 2)
+
+ assert fraction(x) == (x, 1)
+ assert fraction(1/x) == (1, x)
+ assert fraction(x/y) == (x, y)
+ assert fraction(x/2) == (x, 2)
+
+ assert fraction(x*y/z) == (x*y, z)
+ assert fraction(x/(y*z)) == (x, y*z)
+
+ assert fraction(1/y**2) == (1, y**2)
+ assert fraction(x/y**2) == (x, y**2)
+
+ assert fraction((x**2 + 1)/y) == (x**2 + 1, y)
+ assert fraction(x*(y + 1)/y**7) == (x*(y + 1), y**7)
+
+ assert fraction(exp(-x), exact=True) == (exp(-x), 1)
+ assert fraction((1/(x + y))/2, exact=True) == (1, Mul(2,(x + y), evaluate=False))
+
+ assert fraction(x*A/y) == (x*A, y)
+ assert fraction(x*A**-1/y) == (x*A**-1, y)
+
+ n = symbols('n', negative=True)
+ assert fraction(exp(n)) == (1, exp(-n))
+ assert fraction(exp(-n)) == (exp(-n), 1)
+
+ p = symbols('p', positive=True)
+ assert fraction(exp(-p)*log(p), exact=True) == (exp(-p)*log(p), 1)
+
+ m = Mul(1, 1, S.Half, evaluate=False)
+ assert fraction(m) == (1, 2)
+ assert fraction(m, exact=True) == (Mul(1, 1, evaluate=False), 2)
+
+ m = Mul(1, 1, S.Half, S.Half, Pow(1, -1, evaluate=False), evaluate=False)
+ assert fraction(m) == (1, 4)
+ assert fraction(m, exact=True) == \
+ (Mul(1, 1, evaluate=False), Mul(2, 2, 1, evaluate=False))
+
+
+def test_issue_5615():
+ aA, Re, a, b, D = symbols('aA Re a b D')
+ e = ((D**3*a + b*aA**3)/Re).expand()
+ assert collect(e, [aA**3/Re, a]) == e
+
+
+def test_issue_5933():
+ from sympy.geometry.polygon import (Polygon, RegularPolygon)
+ from sympy.simplify.radsimp import denom
+ x = Polygon(*RegularPolygon((0, 0), 1, 5).vertices).centroid.x
+ assert abs(denom(x).n()) > 1e-12
+ assert abs(denom(radsimp(x))) > 1e-12 # in case simplify didn't handle it
+
+
+def test_issue_14608():
+ a, b = symbols('a b', commutative=False)
+ x, y = symbols('x y')
+ raises(AttributeError, lambda: collect(a*b + b*a, a))
+ assert collect(x*y + y*(x+1), a) == x*y + y*(x+1)
+ assert collect(x*y + y*(x+1) + a*b + b*a, y) == y*(2*x + 1) + a*b + b*a
+
+
+def test_collect_abs():
+ s = abs(x) + abs(y)
+ assert collect_abs(s) == s
+ assert unchanged(Mul, abs(x), abs(y))
+ ans = Abs(x*y)
+ assert isinstance(ans, Abs)
+ assert collect_abs(abs(x)*abs(y)) == ans
+ assert collect_abs(1 + exp(abs(x)*abs(y))) == 1 + exp(ans)
+
+ # See https://github.com/sympy/sympy/issues/12910
+ p = Symbol('p', positive=True)
+ assert collect_abs(p/abs(1-p)).is_commutative is True
+
+
+def test_issue_19149():
+ eq = exp(3*x/4)
+ assert collect(eq, exp(x)) == eq
+
+def test_issue_19719():
+ a, b = symbols('a, b')
+ expr = a**2 * (b + 1) + (7 + 1/b)/a
+ collected = collect(expr, (a**2, 1/a), evaluate=False)
+ # Would return {_Dummy_20**(-2): b + 1, 1/a: 7 + 1/b} without xreplace
+ assert collected == {a**2: b + 1, 1/a: 7 + 1/b}
+
+
+def test_issue_21355():
+ assert radsimp(1/(x + sqrt(x**2))) == 1/(x + sqrt(x**2))
+ assert radsimp(1/(x - sqrt(x**2))) == 1/(x - sqrt(x**2))
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_ratsimp.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_ratsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..14e84fd2b227518baff1bda4e5b27ecc40a8bcdd
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_ratsimp.py
@@ -0,0 +1,78 @@
+from sympy.core.numbers import (Rational, pi)
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.error_functions import erf
+from sympy.polys.domains import GF
+from sympy.simplify.ratsimp import (ratsimp, ratsimpmodprime)
+
+from sympy.abc import x, y, z, t, a, b, c, d, e
+
+
+def test_ratsimp():
+ f, g = 1/x + 1/y, (x + y)/(x*y)
+
+ assert f != g and ratsimp(f) == g
+
+ f, g = 1/(1 + 1/x), 1 - 1/(x + 1)
+
+ assert f != g and ratsimp(f) == g
+
+ f, g = x/(x + y) + y/(x + y), 1
+
+ assert f != g and ratsimp(f) == g
+
+ f, g = -x - y - y**2/(x + y) + x**2/(x + y), -2*y
+
+ assert f != g and ratsimp(f) == g
+
+ f = (a*c*x*y + a*c*z - b*d*x*y - b*d*z - b*t*x*y - b*t*x - b*t*z +
+ e*x)/(x*y + z)
+ G = [a*c - b*d - b*t + (-b*t*x + e*x)/(x*y + z),
+ a*c - b*d - b*t - ( b*t*x - e*x)/(x*y + z)]
+
+ assert f != g and ratsimp(f) in G
+
+ A = sqrt(pi)
+
+ B = log(erf(x) - 1)
+ C = log(erf(x) + 1)
+
+ D = 8 - 8*erf(x)
+
+ f = A*B/D - A*C/D + A*C*erf(x)/D - A*B*erf(x)/D + 2*A/D
+
+ assert ratsimp(f) == A*B/8 - A*C/8 - A/(4*erf(x) - 4)
+
+
+def test_ratsimpmodprime():
+ a = y**5 + x + y
+ b = x - y
+ F = [x*y**5 - x - y]
+ assert ratsimpmodprime(a/b, F, x, y, order='lex') == \
+ (-x**2 - x*y - x - y) / (-x**2 + x*y)
+
+ a = x + y**2 - 2
+ b = x + y**2 - y - 1
+ F = [x*y - 1]
+ assert ratsimpmodprime(a/b, F, x, y, order='lex') == \
+ (1 + y - x)/(y - x)
+
+ a = 5*x**3 + 21*x**2 + 4*x*y + 23*x + 12*y + 15
+ b = 7*x**3 - y*x**2 + 31*x**2 + 2*x*y + 15*y + 37*x + 21
+ F = [x**2 + y**2 - 1]
+ assert ratsimpmodprime(a/b, F, x, y, order='lex') == \
+ (1 + 5*y - 5*x)/(8*y - 6*x)
+
+ a = x*y - x - 2*y + 4
+ b = x + y**2 - 2*y
+ F = [x - 2, y - 3]
+ assert ratsimpmodprime(a/b, F, x, y, order='lex') == \
+ Rational(2, 5)
+
+ # Test a bug where denominators would be dropped
+ assert ratsimpmodprime(x, [y - 2*x], order='lex') == \
+ y/2
+
+ a = (x**5 + 2*x**4 + 2*x**3 + 2*x**2 + x + 2/x + x**(-2))
+ assert ratsimpmodprime(a, [x + 1], domain=GF(2)) == 1
+ assert ratsimpmodprime(a, [x + 1], domain=GF(3)) == -1
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_rewrite.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_rewrite.py
new file mode 100644
index 0000000000000000000000000000000000000000..56d2fb7a85bd959bd4accc2f36127429efbdbe70
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_rewrite.py
@@ -0,0 +1,31 @@
+from sympy.core.numbers import I
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.trigonometric import (cos, cot, sin)
+from sympy.testing.pytest import _both_exp_pow
+
+x, y, z, n = symbols('x,y,z,n')
+
+
+@_both_exp_pow
+def test_has():
+ assert cot(x).has(x)
+ assert cot(x).has(cot)
+ assert not cot(x).has(sin)
+ assert sin(x).has(x)
+ assert sin(x).has(sin)
+ assert not sin(x).has(cot)
+ assert exp(x).has(exp)
+
+
+@_both_exp_pow
+def test_sin_exp_rewrite():
+ assert sin(x).rewrite(sin, exp) == -I/2*(exp(I*x) - exp(-I*x))
+ assert sin(x).rewrite(sin, exp).rewrite(exp, sin) == sin(x)
+ assert cos(x).rewrite(cos, exp).rewrite(exp, cos) == cos(x)
+ assert (sin(5*y) - sin(
+ 2*x)).rewrite(sin, exp).rewrite(exp, sin) == sin(5*y) - sin(2*x)
+ assert sin(x + y).rewrite(sin, exp).rewrite(exp, sin) == sin(x + y)
+ assert cos(x + y).rewrite(cos, exp).rewrite(exp, cos) == cos(x + y)
+ # This next test currently passes... not clear whether it should or not?
+ assert cos(x).rewrite(cos, exp).rewrite(exp, sin) == cos(x)
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_simplify.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_simplify.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4392b6693757a95fb2c1df562908e7bd0d79b8f
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_simplify.py
@@ -0,0 +1,1087 @@
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.expr import unchanged
+from sympy.core.function import (count_ops, diff, expand, expand_multinomial, Function, Derivative)
+from sympy.core.mul import Mul, _keep_coeff
+from sympy.core import GoldenRatio
+from sympy.core.numbers import (E, Float, I, oo, pi, Rational, zoo)
+from sympy.core.relational import (Eq, Lt, Gt, Ge, Le)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import (binomial, factorial)
+from sympy.functions.elementary.complexes import (Abs, sign)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import (cosh, csch, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sin, sinc, tan)
+from sympy.functions.special.error_functions import erf
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.geometry.polygon import rad
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.logic.boolalg import (And, Or)
+from sympy.matrices.dense import (Matrix, eye)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.polys.polytools import (factor, Poly)
+from sympy.simplify.simplify import (besselsimp, hypersimp, inversecombine, logcombine, nsimplify, nthroot, posify, separatevars, signsimp, simplify)
+from sympy.solvers.solvers import solve
+
+from sympy.testing.pytest import XFAIL, slow, _both_exp_pow
+from sympy.abc import x, y, z, t, a, b, c, d, e, f, g, h, i, n
+
+
+def test_issue_7263():
+ assert abs((simplify(30.8**2 - 82.5**2 * sin(rad(11.6))**2)).evalf() - \
+ 673.447451402970) < 1e-12
+
+
+def test_factorial_simplify():
+ # There are more tests in test_factorials.py.
+ x = Symbol('x')
+ assert simplify(factorial(x)/x) == gamma(x)
+ assert simplify(factorial(factorial(x))) == factorial(factorial(x))
+
+
+def test_simplify_expr():
+ x, y, z, k, n, m, w, s, A = symbols('x,y,z,k,n,m,w,s,A')
+ f = Function('f')
+
+ assert all(simplify(tmp) == tmp for tmp in [I, E, oo, x, -x, -oo, -E, -I])
+
+ e = 1/x + 1/y
+ assert e != (x + y)/(x*y)
+ assert simplify(e) == (x + y)/(x*y)
+
+ e = A**2*s**4/(4*pi*k*m**3)
+ assert simplify(e) == e
+
+ e = (4 + 4*x - 2*(2 + 2*x))/(2 + 2*x)
+ assert simplify(e) == 0
+
+ e = (-4*x*y**2 - 2*y**3 - 2*x**2*y)/(x + y)**2
+ assert simplify(e) == -2*y
+
+ e = -x - y - (x + y)**(-1)*y**2 + (x + y)**(-1)*x**2
+ assert simplify(e) == -2*y
+
+ e = (x + x*y)/x
+ assert simplify(e) == 1 + y
+
+ e = (f(x) + y*f(x))/f(x)
+ assert simplify(e) == 1 + y
+
+ e = (2 * (1/n - cos(n * pi)/n))/pi
+ assert simplify(e) == (-cos(pi*n) + 1)/(pi*n)*2
+
+ e = integrate(1/(x**3 + 1), x).diff(x)
+ assert simplify(e) == 1/(x**3 + 1)
+
+ e = integrate(x/(x**2 + 3*x + 1), x).diff(x)
+ assert simplify(e) == x/(x**2 + 3*x + 1)
+
+ f = Symbol('f')
+ A = Matrix([[2*k - m*w**2, -k], [-k, k - m*w**2]]).inv()
+ assert simplify((A*Matrix([0, f]))[1] -
+ (-f*(2*k - m*w**2)/(k**2 - (k - m*w**2)*(2*k - m*w**2)))) == 0
+
+ f = -x + y/(z + t) + z*x/(z + t) + z*a/(z + t) + t*x/(z + t)
+ assert simplify(f) == (y + a*z)/(z + t)
+
+ # issue 10347
+ expr = -x*(y**2 - 1)*(2*y**2*(x**2 - 1)/(a*(x**2 - y**2)**2) + (x**2 - 1)
+ /(a*(x**2 - y**2)))/(a*(x**2 - y**2)) + x*(-2*x**2*sqrt(-x**2*y**2 + x**2
+ + y**2 - 1)*sin(z)/(a*(x**2 - y**2)**2) - x**2*sqrt(-x**2*y**2 + x**2 +
+ y**2 - 1)*sin(z)/(a*(x**2 - 1)*(x**2 - y**2)) + (x**2*sqrt((-x**2 + 1)*
+ (y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(x**2 - 1) + sqrt(
+ (-x**2 + 1)*(y**2 - 1))*(x*(-x*y**2 + x)/sqrt(-x**2*y**2 + x**2 + y**2 -
+ 1) + sqrt(-x**2*y**2 + x**2 + y**2 - 1))*sin(z))/(a*sqrt((-x**2 + 1)*(
+ y**2 - 1))*(x**2 - y**2)))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(a*
+ (x**2 - y**2)) + x*(-2*x**2*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*
+ (x**2 - y**2)**2) - x**2*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*
+ (x**2 - 1)*(x**2 - y**2)) + (x**2*sqrt((-x**2 + 1)*(y**2 - 1))*sqrt(-x**2
+ *y**2 + x**2 + y**2 - 1)*cos(z)/(x**2 - 1) + x*sqrt((-x**2 + 1)*(y**2 -
+ 1))*(-x*y**2 + x)*cos(z)/sqrt(-x**2*y**2 + x**2 + y**2 - 1) + sqrt((-x**2
+ + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z))/(a*sqrt((-x**2
+ + 1)*(y**2 - 1))*(x**2 - y**2)))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(
+ z)/(a*(x**2 - y**2)) - y*sqrt((-x**2 + 1)*(y**2 - 1))*(-x*y*sqrt(-x**2*
+ y**2 + x**2 + y**2 - 1)*sin(z)/(a*(x**2 - y**2)*(y**2 - 1)) + 2*x*y*sqrt(
+ -x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(a*(x**2 - y**2)**2) + (x*y*sqrt((
+ -x**2 + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(y**2 -
+ 1) + x*sqrt((-x**2 + 1)*(y**2 - 1))*(-x**2*y + y)*sin(z)/sqrt(-x**2*y**2
+ + x**2 + y**2 - 1))/(a*sqrt((-x**2 + 1)*(y**2 - 1))*(x**2 - y**2)))*sin(
+ z)/(a*(x**2 - y**2)) + y*(x**2 - 1)*(-2*x*y*(x**2 - 1)/(a*(x**2 - y**2)
+ **2) + 2*x*y/(a*(x**2 - y**2)))/(a*(x**2 - y**2)) + y*(x**2 - 1)*(y**2 -
+ 1)*(-x*y*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*(x**2 - y**2)*(y**2
+ - 1)) + 2*x*y*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*(x**2 - y**2)
+ **2) + (x*y*sqrt((-x**2 + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 -
+ 1)*cos(z)/(y**2 - 1) + x*sqrt((-x**2 + 1)*(y**2 - 1))*(-x**2*y + y)*cos(
+ z)/sqrt(-x**2*y**2 + x**2 + y**2 - 1))/(a*sqrt((-x**2 + 1)*(y**2 - 1)
+ )*(x**2 - y**2)))*cos(z)/(a*sqrt((-x**2 + 1)*(y**2 - 1))*(x**2 - y**2)
+ ) - x*sqrt((-x**2 + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(
+ z)**2/(a**2*(x**2 - 1)*(x**2 - y**2)*(y**2 - 1)) - x*sqrt((-x**2 + 1)*(
+ y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)**2/(a**2*(x**2 - 1)*(
+ x**2 - y**2)*(y**2 - 1))
+ assert simplify(expr) == 2*x/(a**2*(x**2 - y**2))
+
+ #issue 17631
+ assert simplify('((-1/2)*Boole(True)*Boole(False)-1)*Boole(True)') == \
+ Mul(sympify('(2 + Boole(True)*Boole(False))'), sympify('-Boole(True)/2'))
+
+ A, B = symbols('A,B', commutative=False)
+
+ assert simplify(A*B - B*A) == A*B - B*A
+ assert simplify(A/(1 + y/x)) == x*A/(x + y)
+ assert simplify(A*(1/x + 1/y)) == A/x + A/y #(x + y)*A/(x*y)
+
+ assert simplify(log(2) + log(3)) == log(6)
+ assert simplify(log(2*x) - log(2)) == log(x)
+
+ assert simplify(hyper([], [], x)) == exp(x)
+
+
+def test_issue_3557():
+ f_1 = x*a + y*b + z*c - 1
+ f_2 = x*d + y*e + z*f - 1
+ f_3 = x*g + y*h + z*i - 1
+
+ solutions = solve([f_1, f_2, f_3], x, y, z, simplify=False)
+
+ assert simplify(solutions[y]) == \
+ (a*i + c*d + f*g - a*f - c*g - d*i)/ \
+ (a*e*i + b*f*g + c*d*h - a*f*h - b*d*i - c*e*g)
+
+
+def test_simplify_other():
+ assert simplify(sin(x)**2 + cos(x)**2) == 1
+ assert simplify(gamma(x + 1)/gamma(x)) == x
+ assert simplify(sin(x)**2 + cos(x)**2 + factorial(x)/gamma(x)) == 1 + x
+ assert simplify(
+ Eq(sin(x)**2 + cos(x)**2, factorial(x)/gamma(x))) == Eq(x, 1)
+ nc = symbols('nc', commutative=False)
+ assert simplify(x + x*nc) == x*(1 + nc)
+ # issue 6123
+ # f = exp(-I*(k*sqrt(t) + x/(2*sqrt(t)))**2)
+ # ans = integrate(f, (k, -oo, oo), conds='none')
+ ans = I*(-pi*x*exp(I*pi*Rational(-3, 4) + I*x**2/(4*t))*erf(x*exp(I*pi*Rational(-3, 4))/
+ (2*sqrt(t)))/(2*sqrt(t)) + pi*x*exp(I*pi*Rational(-3, 4) + I*x**2/(4*t))/
+ (2*sqrt(t)))*exp(-I*x**2/(4*t))/(sqrt(pi)*x) - I*sqrt(pi) * \
+ (-erf(x*exp(I*pi/4)/(2*sqrt(t))) + 1)*exp(I*pi/4)/(2*sqrt(t))
+ assert simplify(ans) == -(-1)**Rational(3, 4)*sqrt(pi)/sqrt(t)
+ # issue 6370
+ assert simplify(2**(2 + x)/4) == 2**x
+
+
+@_both_exp_pow
+def test_simplify_complex():
+ cosAsExp = cos(x)._eval_rewrite_as_exp(x)
+ tanAsExp = tan(x)._eval_rewrite_as_exp(x)
+ assert simplify(cosAsExp*tanAsExp) == sin(x) # issue 4341
+
+ # issue 10124
+ assert simplify(exp(Matrix([[0, -1], [1, 0]]))) == Matrix([[cos(1),
+ -sin(1)], [sin(1), cos(1)]])
+
+
+def test_simplify_ratio():
+ # roots of x**3-3*x+5
+ roots = ['(1/2 - sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3) + 1/((1/2 - '
+ 'sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3))',
+ '1/((1/2 + sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3)) + '
+ '(1/2 + sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3)',
+ '-(sqrt(21)/2 + 5/2)**(1/3) - 1/(sqrt(21)/2 + 5/2)**(1/3)']
+
+ for r in roots:
+ r = S(r)
+ assert count_ops(simplify(r, ratio=1)) <= count_ops(r)
+ # If ratio=oo, simplify() is always applied:
+ assert simplify(r, ratio=oo) is not r
+
+
+def test_simplify_measure():
+ measure1 = lambda expr: len(str(expr))
+ measure2 = lambda expr: -count_ops(expr)
+ # Return the most complicated result
+ expr = (x + 1)/(x + sin(x)**2 + cos(x)**2)
+ assert measure1(simplify(expr, measure=measure1)) <= measure1(expr)
+ assert measure2(simplify(expr, measure=measure2)) <= measure2(expr)
+
+ expr2 = Eq(sin(x)**2 + cos(x)**2, 1)
+ assert measure1(simplify(expr2, measure=measure1)) <= measure1(expr2)
+ assert measure2(simplify(expr2, measure=measure2)) <= measure2(expr2)
+
+
+def test_simplify_rational():
+ expr = 2**x*2.**y
+ assert simplify(expr, rational = True) == 2**(x+y)
+ assert simplify(expr, rational = None) == 2.0**(x+y)
+ assert simplify(expr, rational = False) == expr
+ assert simplify('0.9 - 0.8 - 0.1', rational = True) == 0
+
+
+def test_simplify_issue_1308():
+ assert simplify(exp(Rational(-1, 2)) + exp(Rational(-3, 2))) == \
+ (1 + E)*exp(Rational(-3, 2))
+
+
+def test_issue_5652():
+ assert simplify(E + exp(-E)) == exp(-E) + E
+ n = symbols('n', commutative=False)
+ assert simplify(n + n**(-n)) == n + n**(-n)
+
+
+def test_simplify_fail1():
+ x = Symbol('x')
+ y = Symbol('y')
+ e = (x + y)**2/(-4*x*y**2 - 2*y**3 - 2*x**2*y)
+ assert simplify(e) == 1 / (-2*y)
+
+
+def test_nthroot():
+ assert nthroot(90 + 34*sqrt(7), 3) == sqrt(7) + 3
+ q = 1 + sqrt(2) - 2*sqrt(3) + sqrt(6) + sqrt(7)
+ assert nthroot(expand_multinomial(q**3), 3) == q
+ assert nthroot(41 + 29*sqrt(2), 5) == 1 + sqrt(2)
+ assert nthroot(-41 - 29*sqrt(2), 5) == -1 - sqrt(2)
+ expr = 1320*sqrt(10) + 4216 + 2576*sqrt(6) + 1640*sqrt(15)
+ assert nthroot(expr, 5) == 1 + sqrt(6) + sqrt(15)
+ q = 1 + sqrt(2) + sqrt(3) + sqrt(5)
+ assert expand_multinomial(nthroot(expand_multinomial(q**5), 5)) == q
+ q = 1 + sqrt(2) + 7*sqrt(6) + 2*sqrt(10)
+ assert nthroot(expand_multinomial(q**5), 5, 8) == q
+ q = 1 + sqrt(2) - 2*sqrt(3) + 1171*sqrt(6)
+ assert nthroot(expand_multinomial(q**3), 3) == q
+ assert nthroot(expand_multinomial(q**6), 6) == q
+
+
+def test_nthroot1():
+ q = 1 + sqrt(2) + sqrt(3) + S.One/10**20
+ p = expand_multinomial(q**5)
+ assert nthroot(p, 5) == q
+ q = 1 + sqrt(2) + sqrt(3) + S.One/10**30
+ p = expand_multinomial(q**5)
+ assert nthroot(p, 5) == q
+
+
+@_both_exp_pow
+def test_separatevars():
+ x, y, z, n = symbols('x,y,z,n')
+ assert separatevars(2*n*x*z + 2*x*y*z) == 2*x*z*(n + y)
+ assert separatevars(x*z + x*y*z) == x*z*(1 + y)
+ assert separatevars(pi*x*z + pi*x*y*z) == pi*x*z*(1 + y)
+ assert separatevars(x*y**2*sin(x) + x*sin(x)*sin(y)) == \
+ x*(sin(y) + y**2)*sin(x)
+ assert separatevars(x*exp(x + y) + x*exp(x)) == x*(1 + exp(y))*exp(x)
+ assert separatevars((x*(y + 1))**z).is_Pow # != x**z*(1 + y)**z
+ assert separatevars(1 + x + y + x*y) == (x + 1)*(y + 1)
+ assert separatevars(y/pi*exp(-(z - x)/cos(n))) == \
+ y*exp(x/cos(n))*exp(-z/cos(n))/pi
+ assert separatevars((x + y)*(x - y) + y**2 + 2*x + 1) == (x + 1)**2
+ # issue 4858
+ p = Symbol('p', positive=True)
+ assert separatevars(sqrt(p**2 + x*p**2)) == p*sqrt(1 + x)
+ assert separatevars(sqrt(y*(p**2 + x*p**2))) == p*sqrt(y*(1 + x))
+ assert separatevars(sqrt(y*(p**2 + x*p**2)), force=True) == \
+ p*sqrt(y)*sqrt(1 + x)
+ # issue 4865
+ assert separatevars(sqrt(x*y)).is_Pow
+ assert separatevars(sqrt(x*y), force=True) == sqrt(x)*sqrt(y)
+ # issue 4957
+ # any type sequence for symbols is fine
+ assert separatevars(((2*x + 2)*y), dict=True, symbols=()) == \
+ {'coeff': 1, x: 2*x + 2, y: y}
+ # separable
+ assert separatevars(((2*x + 2)*y), dict=True, symbols=[x]) == \
+ {'coeff': y, x: 2*x + 2}
+ assert separatevars(((2*x + 2)*y), dict=True, symbols=[]) == \
+ {'coeff': 1, x: 2*x + 2, y: y}
+ assert separatevars(((2*x + 2)*y), dict=True) == \
+ {'coeff': 1, x: 2*x + 2, y: y}
+ assert separatevars(((2*x + 2)*y), dict=True, symbols=None) == \
+ {'coeff': y*(2*x + 2)}
+ # not separable
+ assert separatevars(3, dict=True) is None
+ assert separatevars(2*x + y, dict=True, symbols=()) is None
+ assert separatevars(2*x + y, dict=True) is None
+ assert separatevars(2*x + y, dict=True, symbols=None) == {'coeff': 2*x + y}
+ # issue 4808
+ n, m = symbols('n,m', commutative=False)
+ assert separatevars(m + n*m) == (1 + n)*m
+ assert separatevars(x + x*n) == x*(1 + n)
+ # issue 4910
+ f = Function('f')
+ assert separatevars(f(x) + x*f(x)) == f(x) + x*f(x)
+ # a noncommutable object present
+ eq = x*(1 + hyper((), (), y*z))
+ assert separatevars(eq) == eq
+
+ s = separatevars(abs(x*y))
+ assert s == abs(x)*abs(y) and s.is_Mul
+ z = cos(1)**2 + sin(1)**2 - 1
+ a = abs(x*z)
+ s = separatevars(a)
+ assert not a.is_Mul and s.is_Mul and s == abs(x)*abs(z)
+ s = separatevars(abs(x*y*z))
+ assert s == abs(x)*abs(y)*abs(z)
+
+ # abs(x+y)/abs(z) would be better but we test this here to
+ # see that it doesn't raise
+ assert separatevars(abs((x+y)/z)) == abs((x+y)/z)
+
+
+def test_separatevars_advanced_factor():
+ x, y, z = symbols('x,y,z')
+ assert separatevars(1 + log(x)*log(y) + log(x) + log(y)) == \
+ (log(x) + 1)*(log(y) + 1)
+ assert separatevars(1 + x - log(z) - x*log(z) - exp(y)*log(z) -
+ x*exp(y)*log(z) + x*exp(y) + exp(y)) == \
+ -((x + 1)*(log(z) - 1)*(exp(y) + 1))
+ x, y = symbols('x,y', positive=True)
+ assert separatevars(1 + log(x**log(y)) + log(x*y)) == \
+ (log(x) + 1)*(log(y) + 1)
+
+
+def test_hypersimp():
+ n, k = symbols('n,k', integer=True)
+
+ assert hypersimp(factorial(k), k) == k + 1
+ assert hypersimp(factorial(k**2), k) is None
+
+ assert hypersimp(1/factorial(k), k) == 1/(k + 1)
+
+ assert hypersimp(2**k/factorial(k)**2, k) == 2/(k + 1)**2
+
+ assert hypersimp(binomial(n, k), k) == (n - k)/(k + 1)
+ assert hypersimp(binomial(n + 1, k), k) == (n - k + 1)/(k + 1)
+
+ term = (4*k + 1)*factorial(k)/factorial(2*k + 1)
+ assert hypersimp(term, k) == S.Half*((4*k + 5)/(3 + 14*k + 8*k**2))
+
+ term = 1/((2*k - 1)*factorial(2*k + 1))
+ assert hypersimp(term, k) == (k - S.Half)/((k + 1)*(2*k + 1)*(2*k + 3))
+
+ term = binomial(n, k)*(-1)**k/factorial(k)
+ assert hypersimp(term, k) == (k - n)/(k + 1)**2
+
+
+def test_nsimplify():
+ x = Symbol("x")
+ assert nsimplify(0) == 0
+ assert nsimplify(-1) == -1
+ assert nsimplify(1) == 1
+ assert nsimplify(1 + x) == 1 + x
+ assert nsimplify(2.7) == Rational(27, 10)
+ assert nsimplify(1 - GoldenRatio) == (1 - sqrt(5))/2
+ assert nsimplify((1 + sqrt(5))/4, [GoldenRatio]) == GoldenRatio/2
+ assert nsimplify(2/GoldenRatio, [GoldenRatio]) == 2*GoldenRatio - 2
+ assert nsimplify(exp(pi*I*Rational(5, 3), evaluate=False)) == \
+ sympify('1/2 - sqrt(3)*I/2')
+ assert nsimplify(sin(pi*Rational(3, 5), evaluate=False)) == \
+ sympify('sqrt(sqrt(5)/8 + 5/8)')
+ assert nsimplify(sqrt(atan('1', evaluate=False))*(2 + I), [pi]) == \
+ sqrt(pi) + sqrt(pi)/2*I
+ assert nsimplify(2 + exp(2*atan('1/4')*I)) == sympify('49/17 + 8*I/17')
+ assert nsimplify(pi, tolerance=0.01) == Rational(22, 7)
+ assert nsimplify(pi, tolerance=0.001) == Rational(355, 113)
+ assert nsimplify(0.33333, tolerance=1e-4) == Rational(1, 3)
+ assert nsimplify(2.0**(1/3.), tolerance=0.001) == Rational(635, 504)
+ assert nsimplify(2.0**(1/3.), tolerance=0.001, full=True) == \
+ 2**Rational(1, 3)
+ assert nsimplify(x + .5, rational=True) == S.Half + x
+ assert nsimplify(1/.3 + x, rational=True) == Rational(10, 3) + x
+ assert nsimplify(log(3).n(), rational=True) == \
+ sympify('109861228866811/100000000000000')
+ assert nsimplify(Float(0.272198261287950), [pi, log(2)]) == pi*log(2)/8
+ assert nsimplify(Float(0.272198261287950).n(3), [pi, log(2)]) == \
+ -pi/4 - log(2) + Rational(7, 4)
+ assert nsimplify(x/7.0) == x/7
+ assert nsimplify(pi/1e2) == pi/100
+ assert nsimplify(pi/1e2, rational=False) == pi/100.0
+ assert nsimplify(pi/1e-7) == 10000000*pi
+ assert not nsimplify(
+ factor(-3.0*z**2*(z**2)**(-2.5) + 3*(z**2)**(-1.5))).atoms(Float)
+ e = x**0.0
+ assert e.is_Pow and nsimplify(x**0.0) == 1
+ assert nsimplify(3.333333, tolerance=0.1, rational=True) == Rational(10, 3)
+ assert nsimplify(3.333333, tolerance=0.01, rational=True) == Rational(10, 3)
+ assert nsimplify(3.666666, tolerance=0.1, rational=True) == Rational(11, 3)
+ assert nsimplify(3.666666, tolerance=0.01, rational=True) == Rational(11, 3)
+ assert nsimplify(33, tolerance=10, rational=True) == Rational(33)
+ assert nsimplify(33.33, tolerance=10, rational=True) == Rational(30)
+ assert nsimplify(37.76, tolerance=10, rational=True) == Rational(40)
+ assert nsimplify(-203.1) == Rational(-2031, 10)
+ assert nsimplify(.2, tolerance=0) == Rational(1, 5)
+ assert nsimplify(-.2, tolerance=0) == Rational(-1, 5)
+ assert nsimplify(.2222, tolerance=0) == Rational(1111, 5000)
+ assert nsimplify(-.2222, tolerance=0) == Rational(-1111, 5000)
+ # issue 7211, PR 4112
+ assert nsimplify(S(2e-8)) == Rational(1, 50000000)
+ # issue 7322 direct test
+ assert nsimplify(1e-42, rational=True) != 0
+ # issue 10336
+ inf = Float('inf')
+ infs = (-oo, oo, inf, -inf)
+ for zi in infs:
+ ans = sign(zi)*oo
+ assert nsimplify(zi) == ans
+ assert nsimplify(zi + x) == x + ans
+
+ assert nsimplify(0.33333333, rational=True, rational_conversion='exact') == Rational(0.33333333)
+
+ # Make sure nsimplify on expressions uses full precision
+ assert nsimplify(pi.evalf(100)*x, rational_conversion='exact').evalf(100) == pi.evalf(100)*x
+
+
+def test_issue_9448():
+ tmp = sympify("1/(1 - (-1)**(2/3) - (-1)**(1/3)) + 1/(1 + (-1)**(2/3) + (-1)**(1/3))")
+ assert nsimplify(tmp) == S.Half
+
+
+def test_extract_minus_sign():
+ x = Symbol("x")
+ y = Symbol("y")
+ a = Symbol("a")
+ b = Symbol("b")
+ assert simplify(-x/-y) == x/y
+ assert simplify(-x/y) == -x/y
+ assert simplify(x/y) == x/y
+ assert simplify(x/-y) == -x/y
+ assert simplify(-x/0) == zoo*x
+ assert simplify(Rational(-5, 0)) is zoo
+ assert simplify(-a*x/(-y - b)) == a*x/(b + y)
+
+
+def test_diff():
+ x = Symbol("x")
+ y = Symbol("y")
+ f = Function("f")
+ g = Function("g")
+ assert simplify(g(x).diff(x)*f(x).diff(x) - f(x).diff(x)*g(x).diff(x)) == 0
+ assert simplify(2*f(x)*f(x).diff(x) - diff(f(x)**2, x)) == 0
+ assert simplify(diff(1/f(x), x) + f(x).diff(x)/f(x)**2) == 0
+ assert simplify(f(x).diff(x, y) - f(x).diff(y, x)) == 0
+
+
+def test_logcombine_1():
+ x, y = symbols("x,y")
+ a = Symbol("a")
+ z, w = symbols("z,w", positive=True)
+ b = Symbol("b", real=True)
+ assert logcombine(log(x) + 2*log(y)) == log(x) + 2*log(y)
+ assert logcombine(log(x) + 2*log(y), force=True) == log(x*y**2)
+ assert logcombine(a*log(w) + log(z)) == a*log(w) + log(z)
+ assert logcombine(b*log(z) + b*log(x)) == log(z**b) + b*log(x)
+ assert logcombine(b*log(z) - log(w)) == log(z**b/w)
+ assert logcombine(log(x)*log(z)) == log(x)*log(z)
+ assert logcombine(log(w)*log(x)) == log(w)*log(x)
+ assert logcombine(cos(-2*log(z) + b*log(w))) in [cos(log(w**b/z**2)),
+ cos(log(z**2/w**b))]
+ assert logcombine(log(log(x) - log(y)) - log(z), force=True) == \
+ log(log(x/y)/z)
+ assert logcombine((2 + I)*log(x), force=True) == (2 + I)*log(x)
+ assert logcombine((x**2 + log(x) - log(y))/(x*y), force=True) == \
+ (x**2 + log(x/y))/(x*y)
+ # the following could also give log(z*x**log(y**2)), what we
+ # are testing is that a canonical result is obtained
+ assert logcombine(log(x)*2*log(y) + log(z), force=True) == \
+ log(z*y**log(x**2))
+ assert logcombine((x*y + sqrt(x**4 + y**4) + log(x) - log(y))/(pi*x**Rational(2, 3)*
+ sqrt(y)**3), force=True) == (
+ x*y + sqrt(x**4 + y**4) + log(x/y))/(pi*x**Rational(2, 3)*y**Rational(3, 2))
+ assert logcombine(gamma(-log(x/y))*acos(-log(x/y)), force=True) == \
+ acos(-log(x/y))*gamma(-log(x/y))
+
+ assert logcombine(2*log(z)*log(w)*log(x) + log(z) + log(w)) == \
+ log(z**log(w**2))*log(x) + log(w*z)
+ assert logcombine(3*log(w) + 3*log(z)) == log(w**3*z**3)
+ assert logcombine(x*(y + 1) + log(2) + log(3)) == x*(y + 1) + log(6)
+ assert logcombine((x + y)*log(w) + (-x - y)*log(3)) == (x + y)*log(w/3)
+ # a single unknown can combine
+ assert logcombine(log(x) + log(2)) == log(2*x)
+ eq = log(abs(x)) + log(abs(y))
+ assert logcombine(eq) == eq
+ reps = {x: 0, y: 0}
+ assert log(abs(x)*abs(y)).subs(reps) != eq.subs(reps)
+
+
+def test_logcombine_complex_coeff():
+ i = Integral((sin(x**2) + cos(x**3))/x, x)
+ assert logcombine(i, force=True) == i
+ assert logcombine(i + 2*log(x), force=True) == \
+ i + log(x**2)
+
+
+def test_issue_5950():
+ x, y = symbols("x,y", positive=True)
+ assert logcombine(log(3) - log(2)) == log(Rational(3,2), evaluate=False)
+ assert logcombine(log(x) - log(y)) == log(x/y)
+ assert logcombine(log(Rational(3,2), evaluate=False) - log(2)) == \
+ log(Rational(3,4), evaluate=False)
+
+
+def test_posify():
+ x = symbols('x')
+
+ assert str(posify(
+ x +
+ Symbol('p', positive=True) +
+ Symbol('n', negative=True))) == '(_x + n + p, {_x: x})'
+
+ eq, rep = posify(1/x)
+ assert log(eq).expand().subs(rep) == -log(x)
+ assert str(posify([x, 1 + x])) == '([_x, _x + 1], {_x: x})'
+
+ p = symbols('p', positive=True)
+ n = symbols('n', negative=True)
+ orig = [x, n, p]
+ modified, reps = posify(orig)
+ assert str(modified) == '[_x, n, p]'
+ assert [w.subs(reps) for w in modified] == orig
+
+ assert str(Integral(posify(1/x + y)[0], (y, 1, 3)).expand()) == \
+ 'Integral(1/_x, (y, 1, 3)) + Integral(_y, (y, 1, 3))'
+ assert str(Sum(posify(1/x**n)[0], (n,1,3)).expand()) == \
+ 'Sum(_x**(-n), (n, 1, 3))'
+
+ # issue 16438
+ k = Symbol('k', finite=True)
+ eq, rep = posify(k)
+ assert eq.assumptions0 == {'positive': True, 'zero': False, 'imaginary': False,
+ 'nonpositive': False, 'commutative': True, 'hermitian': True, 'real': True, 'nonzero': True,
+ 'nonnegative': True, 'negative': False, 'complex': True, 'finite': True,
+ 'infinite': False, 'extended_real':True, 'extended_negative': False,
+ 'extended_nonnegative': True, 'extended_nonpositive': False,
+ 'extended_nonzero': True, 'extended_positive': True}
+
+
+def test_issue_4194():
+ # simplify should call cancel
+ f = Function('f')
+ assert simplify((4*x + 6*f(y))/(2*x + 3*f(y))) == 2
+
+
+@XFAIL
+def test_simplify_float_vs_integer():
+ # Test for issue 4473:
+ # https://github.com/sympy/sympy/issues/4473
+ assert simplify(x**2.0 - x**2) == 0
+ assert simplify(x**2 - x**2.0) == 0
+
+
+def test_as_content_primitive():
+ assert (x/2 + y).as_content_primitive() == (S.Half, x + 2*y)
+ assert (x/2 + y).as_content_primitive(clear=False) == (S.One, x/2 + y)
+ assert (y*(x/2 + y)).as_content_primitive() == (S.Half, y*(x + 2*y))
+ assert (y*(x/2 + y)).as_content_primitive(clear=False) == (S.One, y*(x/2 + y))
+
+ # although the _as_content_primitive methods do not alter the underlying structure,
+ # the as_content_primitive function will touch up the expression and join
+ # bases that would otherwise have not been joined.
+ assert (x*(2 + 2*x)*(3*x + 3)**2).as_content_primitive() == \
+ (18, x*(x + 1)**3)
+ assert (2 + 2*x + 2*y*(3 + 3*y)).as_content_primitive() == \
+ (2, x + 3*y*(y + 1) + 1)
+ assert ((2 + 6*x)**2).as_content_primitive() == \
+ (4, (3*x + 1)**2)
+ assert ((2 + 6*x)**(2*y)).as_content_primitive() == \
+ (1, (_keep_coeff(S(2), (3*x + 1)))**(2*y))
+ assert (5 + 10*x + 2*y*(3 + 3*y)).as_content_primitive() == \
+ (1, 10*x + 6*y*(y + 1) + 5)
+ assert (5*(x*(1 + y)) + 2*x*(3 + 3*y)).as_content_primitive() == \
+ (11, x*(y + 1))
+ assert ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive() == \
+ (121, x**2*(y + 1)**2)
+ assert (y**2).as_content_primitive() == \
+ (1, y**2)
+ assert (S.Infinity).as_content_primitive() == (1, oo)
+ eq = x**(2 + y)
+ assert (eq).as_content_primitive() == (1, eq)
+ assert (S.Half**(2 + x)).as_content_primitive() == (Rational(1, 4), 2**-x)
+ assert (Rational(-1, 2)**(2 + x)).as_content_primitive() == \
+ (Rational(1, 4), (Rational(-1, 2))**x)
+ assert (Rational(-1, 2)**(2 + x)).as_content_primitive() == \
+ (Rational(1, 4), Rational(-1, 2)**x)
+ assert (4**((1 + y)/2)).as_content_primitive() == (2, 4**(y/2))
+ assert (3**((1 + y)/2)).as_content_primitive() == \
+ (1, 3**(Mul(S.Half, 1 + y, evaluate=False)))
+ assert (5**Rational(3, 4)).as_content_primitive() == (1, 5**Rational(3, 4))
+ assert (5**Rational(7, 4)).as_content_primitive() == (5, 5**Rational(3, 4))
+ assert Add(z*Rational(5, 7), 0.5*x, y*Rational(3, 2), evaluate=False).as_content_primitive() == \
+ (Rational(1, 14), 7.0*x + 21*y + 10*z)
+ assert (2**Rational(3, 4) + 2**Rational(1, 4)*sqrt(3)).as_content_primitive(radical=True) == \
+ (1, 2**Rational(1, 4)*(sqrt(2) + sqrt(3)))
+
+
+def test_signsimp():
+ e = x*(-x + 1) + x*(x - 1)
+ assert signsimp(Eq(e, 0)) is S.true
+ assert Abs(x - 1) == Abs(1 - x)
+ assert signsimp(y - x) == y - x
+ assert signsimp(y - x, evaluate=False) == Mul(-1, x - y, evaluate=False)
+
+
+def test_besselsimp():
+ from sympy.functions.special.bessel import (besseli, besselj, bessely)
+ from sympy.integrals.transforms import cosine_transform
+ assert besselsimp(exp(-I*pi*y/2)*besseli(y, z*exp_polar(I*pi/2))) == \
+ besselj(y, z)
+ assert besselsimp(exp(-I*pi*a/2)*besseli(a, 2*sqrt(x)*exp_polar(I*pi/2))) == \
+ besselj(a, 2*sqrt(x))
+ assert besselsimp(sqrt(2)*sqrt(pi)*x**Rational(1, 4)*exp(I*pi/4)*exp(-I*pi*a/2) *
+ besseli(Rational(-1, 2), sqrt(x)*exp_polar(I*pi/2)) *
+ besseli(a, sqrt(x)*exp_polar(I*pi/2))/2) == \
+ besselj(a, sqrt(x)) * cos(sqrt(x))
+ assert besselsimp(besseli(Rational(-1, 2), z)) == \
+ sqrt(2)*cosh(z)/(sqrt(pi)*sqrt(z))
+ assert besselsimp(besseli(a, z*exp_polar(-I*pi/2))) == \
+ exp(-I*pi*a/2)*besselj(a, z)
+ assert cosine_transform(1/t*sin(a/t), t, y) == \
+ sqrt(2)*sqrt(pi)*besselj(0, 2*sqrt(a)*sqrt(y))/2
+
+ assert besselsimp(x**2*(a*(-2*besselj(5*I, x) + besselj(-2 + 5*I, x) +
+ besselj(2 + 5*I, x)) + b*(-2*bessely(5*I, x) + bessely(-2 + 5*I, x) +
+ bessely(2 + 5*I, x)))/4 + x*(a*(besselj(-1 + 5*I, x)/2 - besselj(1 + 5*I, x)/2)
+ + b*(bessely(-1 + 5*I, x)/2 - bessely(1 + 5*I, x)/2)) + (x**2 + 25)*(a*besselj(5*I, x)
+ + b*bessely(5*I, x))) == 0
+
+ assert besselsimp(81*x**2*(a*(besselj(Rational(-5, 3), 9*x) - 2*besselj(Rational(1, 3), 9*x) + besselj(Rational(7, 3), 9*x))
+ + b*(bessely(Rational(-5, 3), 9*x) - 2*bessely(Rational(1, 3), 9*x) + bessely(Rational(7, 3), 9*x)))/4 + x*(a*(9*besselj(Rational(-2, 3), 9*x)/2
+ - 9*besselj(Rational(4, 3), 9*x)/2) + b*(9*bessely(Rational(-2, 3), 9*x)/2 - 9*bessely(Rational(4, 3), 9*x)/2)) +
+ (81*x**2 - Rational(1, 9))*(a*besselj(Rational(1, 3), 9*x) + b*bessely(Rational(1, 3), 9*x))) == 0
+
+ assert besselsimp(besselj(a-1,x) + besselj(a+1, x) - 2*a*besselj(a, x)/x) == 0
+
+ assert besselsimp(besselj(a-1,x) + besselj(a+1, x) + besselj(a, x)) == (2*a + x)*besselj(a, x)/x
+
+ assert besselsimp(x**2* besselj(a,x) + x**3*besselj(a+1, x) + besselj(a+2, x)) == \
+ 2*a*x*besselj(a + 1, x) + x**3*besselj(a + 1, x) - x**2*besselj(a + 2, x) + 2*x*besselj(a + 1, x) + besselj(a + 2, x)
+
+def test_Piecewise():
+ e1 = x*(x + y) - y*(x + y)
+ e2 = sin(x)**2 + cos(x)**2
+ e3 = expand((x + y)*y/x)
+ s1 = simplify(e1)
+ s2 = simplify(e2)
+ s3 = simplify(e3)
+ assert simplify(Piecewise((e1, x < e2), (e3, True))) == \
+ Piecewise((s1, x < s2), (s3, True))
+
+
+def test_polymorphism():
+ class A(Basic):
+ def _eval_simplify(x, **kwargs):
+ return S.One
+
+ a = A(S(5), S(2))
+ assert simplify(a) == 1
+
+
+def test_issue_from_PR1599():
+ n1, n2, n3, n4 = symbols('n1 n2 n3 n4', negative=True)
+ assert simplify(I*sqrt(n1)) == -sqrt(-n1)
+
+
+def test_issue_6811():
+ eq = (x + 2*y)*(2*x + 2)
+ assert simplify(eq) == (x + 1)*(x + 2*y)*2
+ # reject the 2-arg Mul -- these are a headache for test writing
+ assert simplify(eq.expand()) == \
+ 2*x**2 + 4*x*y + 2*x + 4*y
+
+
+def test_issue_6920():
+ e = [cos(x) + I*sin(x), cos(x) - I*sin(x),
+ cosh(x) - sinh(x), cosh(x) + sinh(x)]
+ ok = [exp(I*x), exp(-I*x), exp(-x), exp(x)]
+ # wrap in f to show that the change happens wherever ei occurs
+ f = Function('f')
+ assert [simplify(f(ei)).args[0] for ei in e] == ok
+
+
+def test_issue_7001():
+ from sympy.abc import r, R
+ assert simplify(-(r*Piecewise((pi*Rational(4, 3), r <= R),
+ (-8*pi*R**3/(3*r**3), True)) + 2*Piecewise((pi*r*Rational(4, 3), r <= R),
+ (4*pi*R**3/(3*r**2), True)))/(4*pi*r)) == \
+ Piecewise((-1, r <= R), (0, True))
+
+
+def test_inequality_no_auto_simplify():
+ # no simplify on creation but can be simplified
+ lhs = cos(x)**2 + sin(x)**2
+ rhs = 2
+ e = Lt(lhs, rhs, evaluate=False)
+ assert e is not S.true
+ assert simplify(e)
+
+
+def test_issue_9398():
+ from sympy.core.numbers import Number
+ from sympy.polys.polytools import cancel
+ assert cancel(1e-14) != 0
+ assert cancel(1e-14*I) != 0
+
+ assert simplify(1e-14) != 0
+ assert simplify(1e-14*I) != 0
+
+ assert (I*Number(1.)*Number(10)**Number(-14)).simplify() != 0
+
+ assert cancel(1e-20) != 0
+ assert cancel(1e-20*I) != 0
+
+ assert simplify(1e-20) != 0
+ assert simplify(1e-20*I) != 0
+
+ assert cancel(1e-100) != 0
+ assert cancel(1e-100*I) != 0
+
+ assert simplify(1e-100) != 0
+ assert simplify(1e-100*I) != 0
+
+ f = Float("1e-1000")
+ assert cancel(f) != 0
+ assert cancel(f*I) != 0
+
+ assert simplify(f) != 0
+ assert simplify(f*I) != 0
+
+
+def test_issue_9324_simplify():
+ M = MatrixSymbol('M', 10, 10)
+ e = M[0, 0] + M[5, 4] + 1304
+ assert simplify(e) == e
+
+
+def test_issue_9817_simplify():
+ # simplify on trace of substituted explicit quadratic form of matrix
+ # expressions (a scalar) should return without errors (AttributeError)
+ # See issue #9817 and #9190 for the original bug more discussion on this
+ from sympy.matrices.expressions import Identity, trace
+ v = MatrixSymbol('v', 3, 1)
+ A = MatrixSymbol('A', 3, 3)
+ x = Matrix([i + 1 for i in range(3)])
+ X = Identity(3)
+ quadratic = v.T * A * v
+ assert simplify((trace(quadratic.as_explicit())).xreplace({v:x, A:X})) == 14
+
+
+def test_issue_13474():
+ x = Symbol('x')
+ assert simplify(x + csch(sinc(1))) == x + csch(sinc(1))
+
+
+@_both_exp_pow
+def test_simplify_function_inverse():
+ # "inverse" attribute does not guarantee that f(g(x)) is x
+ # so this simplification should not happen automatically.
+ # See issue #12140
+ x, y = symbols('x, y')
+ g = Function('g')
+
+ class f(Function):
+ def inverse(self, argindex=1):
+ return g
+
+ assert simplify(f(g(x))) == f(g(x))
+ assert inversecombine(f(g(x))) == x
+ assert simplify(f(g(x)), inverse=True) == x
+ assert simplify(f(g(sin(x)**2 + cos(x)**2)), inverse=True) == 1
+ assert simplify(f(g(x, y)), inverse=True) == f(g(x, y))
+ assert unchanged(asin, sin(x))
+ assert simplify(asin(sin(x))) == asin(sin(x))
+ assert simplify(2*asin(sin(3*x)), inverse=True) == 6*x
+ assert simplify(log(exp(x))) == log(exp(x))
+ assert simplify(log(exp(x)), inverse=True) == x
+ assert simplify(exp(log(x)), inverse=True) == x
+ assert simplify(log(exp(x), 2), inverse=True) == x/log(2)
+ assert simplify(log(exp(x), 2, evaluate=False), inverse=True) == x/log(2)
+
+
+def test_clear_coefficients():
+ from sympy.simplify.simplify import clear_coefficients
+ assert clear_coefficients(4*y*(6*x + 3)) == (y*(2*x + 1), 0)
+ assert clear_coefficients(4*y*(6*x + 3) - 2) == (y*(2*x + 1), Rational(1, 6))
+ assert clear_coefficients(4*y*(6*x + 3) - 2, x) == (y*(2*x + 1), x/12 + Rational(1, 6))
+ assert clear_coefficients(sqrt(2) - 2) == (sqrt(2), 2)
+ assert clear_coefficients(4*sqrt(2) - 2) == (sqrt(2), S.Half)
+ assert clear_coefficients(S(3), x) == (0, x - 3)
+ assert clear_coefficients(S.Infinity, x) == (S.Infinity, x)
+ assert clear_coefficients(-S.Pi, x) == (S.Pi, -x)
+ assert clear_coefficients(2 - S.Pi/3, x) == (pi, -3*x + 6)
+
+def test_nc_simplify():
+ from sympy.simplify.simplify import nc_simplify
+ from sympy.matrices.expressions import MatPow, Identity
+ from sympy.core import Pow
+ from functools import reduce
+
+ a, b, c, d = symbols('a b c d', commutative = False)
+ x = Symbol('x')
+ A = MatrixSymbol("A", x, x)
+ B = MatrixSymbol("B", x, x)
+ C = MatrixSymbol("C", x, x)
+ D = MatrixSymbol("D", x, x)
+ subst = {a: A, b: B, c: C, d:D}
+ funcs = {Add: lambda x,y: x+y, Mul: lambda x,y: x*y }
+
+ def _to_matrix(expr):
+ if expr in subst:
+ return subst[expr]
+ if isinstance(expr, Pow):
+ return MatPow(_to_matrix(expr.args[0]), expr.args[1])
+ elif isinstance(expr, (Add, Mul)):
+ return reduce(funcs[expr.func],[_to_matrix(a) for a in expr.args])
+ else:
+ return expr*Identity(x)
+
+ def _check(expr, simplified, deep=True, matrix=True):
+ assert nc_simplify(expr, deep=deep) == simplified
+ assert expand(expr) == expand(simplified)
+ if matrix:
+ m_simp = _to_matrix(simplified).doit(inv_expand=False)
+ assert nc_simplify(_to_matrix(expr), deep=deep) == m_simp
+
+ _check(a*b*a*b*a*b*c*(a*b)**3*c, ((a*b)**3*c)**2)
+ _check(a*b*(a*b)**-2*a*b, 1)
+ _check(a**2*b*a*b*a*b*(a*b)**-1, a*(a*b)**2, matrix=False)
+ _check(b*a*b**2*a*b**2*a*b**2, b*(a*b**2)**3)
+ _check(a*b*a**2*b*a**2*b*a**3, (a*b*a)**3*a**2)
+ _check(a**2*b*a**4*b*a**4*b*a**2, (a**2*b*a**2)**3)
+ _check(a**3*b*a**4*b*a**4*b*a, a**3*(b*a**4)**3*a**-3)
+ _check(a*b*a*b + a*b*c*x*a*b*c, (a*b)**2 + x*(a*b*c)**2)
+ _check(a*b*a*b*c*a*b*a*b*c, ((a*b)**2*c)**2)
+ _check(b**-1*a**-1*(a*b)**2, a*b)
+ _check(a**-1*b*c**-1, (c*b**-1*a)**-1)
+ expr = a**3*b*a**4*b*a**4*b*a**2*b*a**2*(b*a**2)**2*b*a**2*b*a**2
+ for _ in range(10):
+ expr *= a*b
+ _check(expr, a**3*(b*a**4)**2*(b*a**2)**6*(a*b)**10)
+ _check((a*b*a*b)**2, (a*b*a*b)**2, deep=False)
+ _check(a*b*(c*d)**2, a*b*(c*d)**2)
+ expr = b**-1*(a**-1*b**-1 - a**-1*c*b**-1)**-1*a**-1
+ assert nc_simplify(expr) == (1-c)**-1
+ # commutative expressions should be returned without an error
+ assert nc_simplify(2*x**2) == 2*x**2
+
+def test_issue_15965():
+ A = Sum(z*x**y, (x, 1, a))
+ anew = z*Sum(x**y, (x, 1, a))
+ B = Integral(x*y, x)
+ bdo = x**2*y/2
+ assert simplify(A + B) == anew + bdo
+ assert simplify(A) == anew
+ assert simplify(B) == bdo
+ assert simplify(B, doit=False) == y*Integral(x, x)
+
+
+def test_issue_17137():
+ assert simplify(cos(x)**I) == cos(x)**I
+ assert simplify(cos(x)**(2 + 3*I)) == cos(x)**(2 + 3*I)
+
+
+def test_issue_21869():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ expr = And(Eq(x**2, 4), Le(x, y))
+ assert expr.simplify() == expr
+
+ expr = And(Eq(x**2, 4), Eq(x, 2))
+ assert expr.simplify() == Eq(x, 2)
+
+ expr = And(Eq(x**3, x**2), Eq(x, 1))
+ assert expr.simplify() == Eq(x, 1)
+
+ expr = And(Eq(sin(x), x**2), Eq(x, 0))
+ assert expr.simplify() == Eq(x, 0)
+
+ expr = And(Eq(x**3, x**2), Eq(x, 2))
+ assert expr.simplify() == S.false
+
+ expr = And(Eq(y, x**2), Eq(x, 1))
+ assert expr.simplify() == And(Eq(y,1), Eq(x, 1))
+
+ expr = And(Eq(y**2, 1), Eq(y, x**2), Eq(x, 1))
+ assert expr.simplify() == And(Eq(y,1), Eq(x, 1))
+
+ expr = And(Eq(y**2, 4), Eq(y, 2*x**2), Eq(x, 1))
+ assert expr.simplify() == And(Eq(y,2), Eq(x, 1))
+
+ expr = And(Eq(y**2, 4), Eq(y, x**2), Eq(x, 1))
+ assert expr.simplify() == S.false
+
+
+def test_issue_7971_21740():
+ z = Integral(x, (x, 1, 1))
+ assert z != 0
+ assert simplify(z) is S.Zero
+ assert simplify(S.Zero) is S.Zero
+ z = simplify(Float(0))
+ assert z is not S.Zero and z == 0.0
+
+
+@slow
+def test_issue_17141_slow():
+ # Should not give RecursionError
+ assert simplify((2**acos(I+1)**2).rewrite('log')) == 2**((pi + 2*I*log(-1 +
+ sqrt(1 - 2*I) + I))**2/4)
+
+
+def test_issue_17141():
+ # Check that there is no RecursionError
+ assert simplify(x**(1 / acos(I))) == x**(2/(pi - 2*I*log(1 + sqrt(2))))
+ assert simplify(acos(-I)**2*acos(I)**2) == \
+ log(1 + sqrt(2))**4 + pi**2*log(1 + sqrt(2))**2/2 + pi**4/16
+ assert simplify(2**acos(I)**2) == 2**((pi - 2*I*log(1 + sqrt(2)))**2/4)
+ p = 2**acos(I+1)**2
+ assert simplify(p) == p
+
+
+def test_simplify_kroneckerdelta():
+ i, j = symbols("i j")
+ K = KroneckerDelta
+
+ assert simplify(K(i, j)) == K(i, j)
+ assert simplify(K(0, j)) == K(0, j)
+ assert simplify(K(i, 0)) == K(i, 0)
+
+ assert simplify(K(0, j).rewrite(Piecewise) * K(1, j)) == 0
+ assert simplify(K(1, i) + Piecewise((1, Eq(j, 2)), (0, True))) == K(1, i) + K(2, j)
+
+ # issue 17214
+ assert simplify(K(0, j) * K(1, j)) == 0
+
+ n = Symbol('n', integer=True)
+ assert simplify(K(0, n) * K(1, n)) == 0
+
+ M = Matrix(4, 4, lambda i, j: K(j - i, n) if i <= j else 0)
+ assert simplify(M**2) == Matrix([[K(0, n), 0, K(1, n), 0],
+ [0, K(0, n), 0, K(1, n)],
+ [0, 0, K(0, n), 0],
+ [0, 0, 0, K(0, n)]])
+ assert simplify(eye(1) * KroneckerDelta(0, n) *
+ KroneckerDelta(1, n)) == Matrix([[0]])
+
+ assert simplify(S.Infinity * KroneckerDelta(0, n) *
+ KroneckerDelta(1, n)) is S.NaN
+
+
+def test_issue_17292():
+ assert simplify(abs(x)/abs(x**2)) == 1/abs(x)
+ # this is bigger than the issue: check that deep processing works
+ assert simplify(5*abs((x**2 - 1)/(x - 1))) == 5*Abs(x + 1)
+
+
+def test_issue_19822():
+ expr = And(Gt(n-2, 1), Gt(n, 1))
+ assert simplify(expr) == Gt(n, 3)
+
+
+def test_issue_18645():
+ expr = And(Ge(x, 3), Le(x, 3))
+ assert simplify(expr) == Eq(x, 3)
+ expr = And(Eq(x, 3), Le(x, 3))
+ assert simplify(expr) == Eq(x, 3)
+
+
+@XFAIL
+def test_issue_18642():
+ i = Symbol("i", integer=True)
+ n = Symbol("n", integer=True)
+ expr = And(Eq(i, 2 * n), Le(i, 2*n -1))
+ assert simplify(expr) == S.false
+
+
+@XFAIL
+def test_issue_18389():
+ n = Symbol("n", integer=True)
+ expr = Eq(n, 0) | (n >= 1)
+ assert simplify(expr) == Ge(n, 0)
+
+
+def test_issue_8373():
+ x = Symbol('x', real=True)
+ assert simplify(Or(x < 1, x >= 1)) == S.true
+
+
+def test_issue_7950():
+ expr = And(Eq(x, 1), Eq(x, 2))
+ assert simplify(expr) == S.false
+
+
+def test_issue_22020():
+ expr = I*pi/2 -oo
+ assert simplify(expr) == expr
+ # Used to throw an error
+
+
+def test_issue_19484():
+ assert simplify(sign(x) * Abs(x)) == x
+
+ e = x + sign(x + x**3)
+ assert simplify(Abs(x + x**3)*e) == x**3 + x*Abs(x**3 + x) + x
+
+ e = x**2 + sign(x**3 + 1)
+ assert simplify(Abs(x**3 + 1) * e) == x**3 + x**2*Abs(x**3 + 1) + 1
+
+ f = Function('f')
+ e = x + sign(x + f(x)**3)
+ assert simplify(Abs(x + f(x)**3) * e) == x*Abs(x + f(x)**3) + x + f(x)**3
+
+
+def test_issue_23543():
+ # Used to give an error
+ x, y, z = symbols("x y z", commutative=False)
+ assert (x*(y + z/2)).simplify() == x*(2*y + z)/2
+
+
+def test_issue_11004():
+
+ def f(n):
+ return sqrt(2*pi*n) * (n/E)**n
+
+ def m(n, k):
+ return f(n) / (f(n/k)**k)
+
+ def p(n,k):
+ return m(n, k) / (k**n)
+
+ N, k = symbols('N k')
+ half = Float('0.5', 4)
+ z = log(p(n, k) / p(n, k + 1)).expand(force=True)
+ r = simplify(z.subs(n, N).n(4))
+ assert r == (
+ half*k*log(k)
+ - half*k*log(k + 1)
+ + half*log(N)
+ - half*log(k + 1)
+ + Float(0.9189224, 4)
+ )
+
+
+def test_issue_19161():
+ polynomial = Poly('x**2').simplify()
+ assert (polynomial-x**2).simplify() == 0
+
+
+def test_issue_22210():
+ d = Symbol('d', integer=True)
+ expr = 2*Derivative(sin(x), (x, d))
+ assert expr.simplify() == expr
+
+
+def test_reduce_inverses_nc_pow():
+ x, y = symbols("x y", commutative=True)
+ Z = symbols("Z", commutative=False)
+ assert simplify(2**Z * y**Z) == 2**Z * y**Z
+ assert simplify(x**Z * y**Z) == x**Z * y**Z
+ x, y = symbols("x y", positive=True)
+ assert expand((x*y)**Z) == x**Z * y**Z
+ assert simplify(x**Z * y**Z) == expand((x*y)**Z)
+
+def test_nc_recursion_coeff():
+ X = symbols("X", commutative = False)
+ assert (2 * cos(pi/3) * X).simplify() == X
+ assert (2.0 * cos(pi/3) * X).simplify() == X
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_sqrtdenest.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_sqrtdenest.py
new file mode 100644
index 0000000000000000000000000000000000000000..41c771bb2055a1199d349ae3649f33927d79313a
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_sqrtdenest.py
@@ -0,0 +1,204 @@
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Integer, Rational)
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import cos
+from sympy.integrals.integrals import Integral
+from sympy.simplify.sqrtdenest import sqrtdenest
+from sympy.simplify.sqrtdenest import (
+ _subsets as subsets, _sqrt_numeric_denest)
+
+r2, r3, r5, r6, r7, r10, r15, r29 = [sqrt(x) for x in (2, 3, 5, 6, 7, 10,
+ 15, 29)]
+
+
+def test_sqrtdenest():
+ d = {sqrt(5 + 2 * r6): r2 + r3,
+ sqrt(5. + 2 * r6): sqrt(5. + 2 * r6),
+ sqrt(5. + 4*sqrt(5 + 2 * r6)): sqrt(5.0 + 4*r2 + 4*r3),
+ sqrt(r2): sqrt(r2),
+ sqrt(5 + r7): sqrt(5 + r7),
+ sqrt(3 + sqrt(5 + 2*r7)):
+ 3*r2*(5 + 2*r7)**Rational(1, 4)/(2*sqrt(6 + 3*r7)) +
+ r2*sqrt(6 + 3*r7)/(2*(5 + 2*r7)**Rational(1, 4)),
+ sqrt(3 + 2*r3): 3**Rational(3, 4)*(r6/2 + 3*r2/2)/3}
+ for i in d:
+ assert sqrtdenest(i) == d[i], i
+
+
+def test_sqrtdenest2():
+ assert sqrtdenest(sqrt(16 - 2*r29 + 2*sqrt(55 - 10*r29))) == \
+ r5 + sqrt(11 - 2*r29)
+ e = sqrt(-r5 + sqrt(-2*r29 + 2*sqrt(-10*r29 + 55) + 16))
+ assert sqrtdenest(e) == root(-2*r29 + 11, 4)
+ r = sqrt(1 + r7)
+ assert sqrtdenest(sqrt(1 + r)) == sqrt(1 + r)
+ e = sqrt(((1 + sqrt(1 + 2*sqrt(3 + r2 + r5)))**2).expand())
+ assert sqrtdenest(e) == 1 + sqrt(1 + 2*sqrt(r2 + r5 + 3))
+
+ assert sqrtdenest(sqrt(5*r3 + 6*r2)) == \
+ sqrt(2)*root(3, 4) + root(3, 4)**3
+
+ assert sqrtdenest(sqrt(((1 + r5 + sqrt(1 + r3))**2).expand())) == \
+ 1 + r5 + sqrt(1 + r3)
+
+ assert sqrtdenest(sqrt(((1 + r5 + r7 + sqrt(1 + r3))**2).expand())) == \
+ 1 + sqrt(1 + r3) + r5 + r7
+
+ e = sqrt(((1 + cos(2) + cos(3) + sqrt(1 + r3))**2).expand())
+ assert sqrtdenest(e) == cos(3) + cos(2) + 1 + sqrt(1 + r3)
+
+ e = sqrt(-2*r10 + 2*r2*sqrt(-2*r10 + 11) + 14)
+ assert sqrtdenest(e) == sqrt(-2*r10 - 2*r2 + 4*r5 + 14)
+
+ # check that the result is not more complicated than the input
+ z = sqrt(-2*r29 + cos(2) + 2*sqrt(-10*r29 + 55) + 16)
+ assert sqrtdenest(z) == z
+
+ assert sqrtdenest(sqrt(r6 + sqrt(15))) == sqrt(r6 + sqrt(15))
+
+ z = sqrt(15 - 2*sqrt(31) + 2*sqrt(55 - 10*r29))
+ assert sqrtdenest(z) == z
+
+
+def test_sqrtdenest_rec():
+ assert sqrtdenest(sqrt(-4*sqrt(14) - 2*r6 + 4*sqrt(21) + 33)) == \
+ -r2 + r3 + 2*r7
+ assert sqrtdenest(sqrt(-28*r7 - 14*r5 + 4*sqrt(35) + 82)) == \
+ -7 + r5 + 2*r7
+ assert sqrtdenest(sqrt(6*r2/11 + 2*sqrt(22)/11 + 6*sqrt(11)/11 + 2)) == \
+ sqrt(11)*(r2 + 3 + sqrt(11))/11
+ assert sqrtdenest(sqrt(468*r3 + 3024*r2 + 2912*r6 + 19735)) == \
+ 9*r3 + 26 + 56*r6
+ z = sqrt(-490*r3 - 98*sqrt(115) - 98*sqrt(345) - 2107)
+ assert sqrtdenest(z) == sqrt(-1)*(7*r5 + 7*r15 + 7*sqrt(23))
+ z = sqrt(-4*sqrt(14) - 2*r6 + 4*sqrt(21) + 34)
+ assert sqrtdenest(z) == z
+ assert sqrtdenest(sqrt(-8*r2 - 2*r5 + 18)) == -r10 + 1 + r2 + r5
+ assert sqrtdenest(sqrt(8*r2 + 2*r5 - 18)) == \
+ sqrt(-1)*(-r10 + 1 + r2 + r5)
+ assert sqrtdenest(sqrt(8*r2/3 + 14*r5/3 + Rational(154, 9))) == \
+ -r10/3 + r2 + r5 + 3
+ assert sqrtdenest(sqrt(sqrt(2*r6 + 5) + sqrt(2*r7 + 8))) == \
+ sqrt(1 + r2 + r3 + r7)
+ assert sqrtdenest(sqrt(4*r15 + 8*r5 + 12*r3 + 24)) == 1 + r3 + r5 + r15
+
+ w = 1 + r2 + r3 + r5 + r7
+ assert sqrtdenest(sqrt((w**2).expand())) == w
+ z = sqrt((w**2).expand() + 1)
+ assert sqrtdenest(z) == z
+
+ z = sqrt(2*r10 + 6*r2 + 4*r5 + 12 + 10*r15 + 30*r3)
+ assert sqrtdenest(z) == z
+
+
+def test_issue_6241():
+ z = sqrt( -320 + 32*sqrt(5) + 64*r15)
+ assert sqrtdenest(z) == z
+
+
+def test_sqrtdenest3():
+ z = sqrt(13 - 2*r10 + 2*r2*sqrt(-2*r10 + 11))
+ assert sqrtdenest(z) == -1 + r2 + r10
+ assert sqrtdenest(z, max_iter=1) == -1 + sqrt(2) + sqrt(10)
+ z = sqrt(sqrt(r2 + 2) + 2)
+ assert sqrtdenest(z) == z
+ assert sqrtdenest(sqrt(-2*r10 + 4*r2*sqrt(-2*r10 + 11) + 20)) == \
+ sqrt(-2*r10 - 4*r2 + 8*r5 + 20)
+ assert sqrtdenest(sqrt((112 + 70*r2) + (46 + 34*r2)*r5)) == \
+ r10 + 5 + 4*r2 + 3*r5
+ z = sqrt(5 + sqrt(2*r6 + 5)*sqrt(-2*r29 + 2*sqrt(-10*r29 + 55) + 16))
+ r = sqrt(-2*r29 + 11)
+ assert sqrtdenest(z) == sqrt(r2*r + r3*r + r10 + r15 + 5)
+
+ n = sqrt(2*r6/7 + 2*r7/7 + 2*sqrt(42)/7 + 2)
+ d = sqrt(16 - 2*r29 + 2*sqrt(55 - 10*r29))
+ assert sqrtdenest(n/d) == r7*(1 + r6 + r7)/(Mul(7, (sqrt(-2*r29 + 11) + r5),
+ evaluate=False))
+
+
+def test_sqrtdenest4():
+ # see Denest_en.pdf in https://github.com/sympy/sympy/issues/3192
+ z = sqrt(8 - r2*sqrt(5 - r5) - sqrt(3)*(1 + r5))
+ z1 = sqrtdenest(z)
+ c = sqrt(-r5 + 5)
+ z1 = ((-r15*c - r3*c + c + r5*c - r6 - r2 + r10 + sqrt(30))/4).expand()
+ assert sqrtdenest(z) == z1
+
+ z = sqrt(2*r2*sqrt(r2 + 2) + 5*r2 + 4*sqrt(r2 + 2) + 8)
+ assert sqrtdenest(z) == r2 + sqrt(r2 + 2) + 2
+
+ w = 2 + r2 + r3 + (1 + r3)*sqrt(2 + r2 + 5*r3)
+ z = sqrt((w**2).expand())
+ assert sqrtdenest(z) == w.expand()
+
+
+def test_sqrt_symbolic_denest():
+ x = Symbol('x')
+ z = sqrt(((1 + sqrt(sqrt(2 + x) + 3))**2).expand())
+ assert sqrtdenest(z) == sqrt((1 + sqrt(sqrt(2 + x) + 3))**2)
+ z = sqrt(((1 + sqrt(sqrt(2 + cos(1)) + 3))**2).expand())
+ assert sqrtdenest(z) == 1 + sqrt(sqrt(2 + cos(1)) + 3)
+ z = ((1 + cos(2))**4 + 1).expand()
+ assert sqrtdenest(z) == z
+ z = sqrt(((1 + sqrt(sqrt(2 + cos(3*x)) + 3))**2 + 1).expand())
+ assert sqrtdenest(z) == z
+ c = cos(3)
+ c2 = c**2
+ assert sqrtdenest(sqrt(2*sqrt(1 + r3)*c + c2 + 1 + r3*c2)) == \
+ -1 - sqrt(1 + r3)*c
+ ra = sqrt(1 + r3)
+ z = sqrt(20*ra*sqrt(3 + 3*r3) + 12*r3*ra*sqrt(3 + 3*r3) + 64*r3 + 112)
+ assert sqrtdenest(z) == z
+
+
+def test_issue_5857():
+ from sympy.abc import x, y
+ z = sqrt(1/(4*r3 + 7) + 1)
+ ans = (r2 + r6)/(r3 + 2)
+ assert sqrtdenest(z) == ans
+ assert sqrtdenest(1 + z) == 1 + ans
+ assert sqrtdenest(Integral(z + 1, (x, 1, 2))) == \
+ Integral(1 + ans, (x, 1, 2))
+ assert sqrtdenest(x + sqrt(y)) == x + sqrt(y)
+ ans = (r2 + r6)/(r3 + 2)
+ assert sqrtdenest(z) == ans
+ assert sqrtdenest(1 + z) == 1 + ans
+ assert sqrtdenest(Integral(z + 1, (x, 1, 2))) == \
+ Integral(1 + ans, (x, 1, 2))
+ assert sqrtdenest(x + sqrt(y)) == x + sqrt(y)
+
+
+def test_subsets():
+ assert subsets(1) == [[1]]
+ assert subsets(4) == [
+ [1, 0, 0, 0], [0, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 0], [1, 0, 1, 0],
+ [0, 1, 1, 0], [1, 1, 1, 0], [0, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 1],
+ [1, 1, 0, 1], [0, 0, 1, 1], [1, 0, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1]]
+
+
+def test_issue_5653():
+ assert sqrtdenest(
+ sqrt(2 + sqrt(2 + sqrt(2)))) == sqrt(2 + sqrt(2 + sqrt(2)))
+
+def test_issue_12420():
+ assert sqrtdenest((3 - sqrt(2)*sqrt(4 + 3*I) + 3*I)/2) == I
+ e = 3 - sqrt(2)*sqrt(4 + I) + 3*I
+ assert sqrtdenest(e) == e
+
+def test_sqrt_ratcomb():
+ assert sqrtdenest(sqrt(1 + r3) + sqrt(3 + 3*r3) - sqrt(10 + 6*r3)) == 0
+
+def test_issue_18041():
+ e = -sqrt(-2 + 2*sqrt(3)*I)
+ assert sqrtdenest(e) == -1 - sqrt(3)*I
+
+def test_issue_19914():
+ a = Integer(-8)
+ b = Integer(-1)
+ r = Integer(63)
+ d2 = a*a - b*b*r
+
+ assert _sqrt_numeric_denest(a, b, r, d2) == \
+ sqrt(14)*I/2 + 3*sqrt(2)*I/2
+ assert sqrtdenest(sqrt(-8-sqrt(63))) == sqrt(14)*I/2 + 3*sqrt(2)*I/2
diff --git a/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_trigsimp.py b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_trigsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea091ec8a6c7d654405968e3d035c2bbe02ccdf7
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/sympy/simplify/tests/test_trigsimp.py
@@ -0,0 +1,520 @@
+from itertools import product
+from sympy.core.function import (Subs, count_ops, diff, expand)
+from sympy.core.numbers import (E, I, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (cosh, coth, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, cot, sin, tan)
+from sympy.functions.elementary.trigonometric import (acos, asin, atan2)
+from sympy.functions.elementary.trigonometric import (asec, acsc)
+from sympy.functions.elementary.trigonometric import (acot, atan)
+from sympy.integrals.integrals import integrate
+from sympy.matrices.dense import Matrix
+from sympy.simplify.simplify import simplify
+from sympy.simplify.trigsimp import (exptrigsimp, trigsimp)
+
+from sympy.testing.pytest import XFAIL
+
+from sympy.abc import x, y
+
+
+
+def test_trigsimp1():
+ x, y = symbols('x,y')
+
+ assert trigsimp(1 - sin(x)**2) == cos(x)**2
+ assert trigsimp(1 - cos(x)**2) == sin(x)**2
+ assert trigsimp(sin(x)**2 + cos(x)**2) == 1
+ assert trigsimp(1 + tan(x)**2) == 1/cos(x)**2
+ assert trigsimp(1/cos(x)**2 - 1) == tan(x)**2
+ assert trigsimp(1/cos(x)**2 - tan(x)**2) == 1
+ assert trigsimp(1 + cot(x)**2) == 1/sin(x)**2
+ assert trigsimp(1/sin(x)**2 - 1) == 1/tan(x)**2
+ assert trigsimp(1/sin(x)**2 - cot(x)**2) == 1
+
+ assert trigsimp(5*cos(x)**2 + 5*sin(x)**2) == 5
+ assert trigsimp(5*cos(x/2)**2 + 2*sin(x/2)**2) == 3*cos(x)/2 + Rational(7, 2)
+
+ assert trigsimp(sin(x)/cos(x)) == tan(x)
+ assert trigsimp(2*tan(x)*cos(x)) == 2*sin(x)
+ assert trigsimp(cot(x)**3*sin(x)**3) == cos(x)**3
+ assert trigsimp(y*tan(x)**2/sin(x)**2) == y/cos(x)**2
+ assert trigsimp(cot(x)/cos(x)) == 1/sin(x)
+
+ assert trigsimp(sin(x + y) + sin(x - y)) == 2*sin(x)*cos(y)
+ assert trigsimp(sin(x + y) - sin(x - y)) == 2*sin(y)*cos(x)
+ assert trigsimp(cos(x + y) + cos(x - y)) == 2*cos(x)*cos(y)
+ assert trigsimp(cos(x + y) - cos(x - y)) == -2*sin(x)*sin(y)
+ assert trigsimp(tan(x + y) - tan(x)/(1 - tan(x)*tan(y))) == \
+ sin(y)/(-sin(y)*tan(x) + cos(y)) # -tan(y)/(tan(x)*tan(y) - 1)
+
+ assert trigsimp(sinh(x + y) + sinh(x - y)) == 2*sinh(x)*cosh(y)
+ assert trigsimp(sinh(x + y) - sinh(x - y)) == 2*sinh(y)*cosh(x)
+ assert trigsimp(cosh(x + y) + cosh(x - y)) == 2*cosh(x)*cosh(y)
+ assert trigsimp(cosh(x + y) - cosh(x - y)) == 2*sinh(x)*sinh(y)
+ assert trigsimp(tanh(x + y) - tanh(x)/(1 + tanh(x)*tanh(y))) == \
+ sinh(y)/(sinh(y)*tanh(x) + cosh(y))
+
+ assert trigsimp(cos(0.12345)**2 + sin(0.12345)**2) == 1.0
+ e = 2*sin(x)**2 + 2*cos(x)**2
+ assert trigsimp(log(e)) == log(2)
+
+
+def test_trigsimp1a():
+ assert trigsimp(sin(2)**2*cos(3)*exp(2)/cos(2)**2) == tan(2)**2*cos(3)*exp(2)
+ assert trigsimp(tan(2)**2*cos(3)*exp(2)*cos(2)**2) == sin(2)**2*cos(3)*exp(2)
+ assert trigsimp(cot(2)*cos(3)*exp(2)*sin(2)) == cos(3)*exp(2)*cos(2)
+ assert trigsimp(tan(2)*cos(3)*exp(2)/sin(2)) == cos(3)*exp(2)/cos(2)
+ assert trigsimp(cot(2)*cos(3)*exp(2)/cos(2)) == cos(3)*exp(2)/sin(2)
+ assert trigsimp(cot(2)*cos(3)*exp(2)*tan(2)) == cos(3)*exp(2)
+ assert trigsimp(sinh(2)*cos(3)*exp(2)/cosh(2)) == tanh(2)*cos(3)*exp(2)
+ assert trigsimp(tanh(2)*cos(3)*exp(2)*cosh(2)) == sinh(2)*cos(3)*exp(2)
+ assert trigsimp(coth(2)*cos(3)*exp(2)*sinh(2)) == cosh(2)*cos(3)*exp(2)
+ assert trigsimp(tanh(2)*cos(3)*exp(2)/sinh(2)) == cos(3)*exp(2)/cosh(2)
+ assert trigsimp(coth(2)*cos(3)*exp(2)/cosh(2)) == cos(3)*exp(2)/sinh(2)
+ assert trigsimp(coth(2)*cos(3)*exp(2)*tanh(2)) == cos(3)*exp(2)
+
+
+def test_trigsimp2():
+ x, y = symbols('x,y')
+ assert trigsimp(cos(x)**2*sin(y)**2 + cos(x)**2*cos(y)**2 + sin(x)**2,
+ recursive=True) == 1
+ assert trigsimp(sin(x)**2*sin(y)**2 + sin(x)**2*cos(y)**2 + cos(x)**2,
+ recursive=True) == 1
+ assert trigsimp(
+ Subs(x, x, sin(y)**2 + cos(y)**2)) == Subs(x, x, 1)
+
+
+def test_issue_4373():
+ x = Symbol("x")
+ assert abs(trigsimp(2.0*sin(x)**2 + 2.0*cos(x)**2) - 2.0) < 1e-10
+
+
+def test_trigsimp3():
+ x, y = symbols('x,y')
+ assert trigsimp(sin(x)/cos(x)) == tan(x)
+ assert trigsimp(sin(x)**2/cos(x)**2) == tan(x)**2
+ assert trigsimp(sin(x)**3/cos(x)**3) == tan(x)**3
+ assert trigsimp(sin(x)**10/cos(x)**10) == tan(x)**10
+
+ assert trigsimp(cos(x)/sin(x)) == 1/tan(x)
+ assert trigsimp(cos(x)**2/sin(x)**2) == 1/tan(x)**2
+ assert trigsimp(cos(x)**10/sin(x)**10) == 1/tan(x)**10
+
+ assert trigsimp(tan(x)) == trigsimp(sin(x)/cos(x))
+
+
+def test_issue_4661():
+ a, x, y = symbols('a x y')
+ eq = -4*sin(x)**4 + 4*cos(x)**4 - 8*cos(x)**2
+ assert trigsimp(eq) == -4
+ n = sin(x)**6 + 4*sin(x)**4*cos(x)**2 + 5*sin(x)**2*cos(x)**4 + 2*cos(x)**6
+ d = -sin(x)**2 - 2*cos(x)**2
+ assert simplify(n/d) == -1
+ assert trigsimp(-2*cos(x)**2 + cos(x)**4 - sin(x)**4) == -1
+ eq = (- sin(x)**3/4)*cos(x) + (cos(x)**3/4)*sin(x) - sin(2*x)*cos(2*x)/8
+ assert trigsimp(eq) == 0
+
+
+def test_issue_4494():
+ a, b = symbols('a b')
+ eq = sin(a)**2*sin(b)**2 + cos(a)**2*cos(b)**2*tan(a)**2 + cos(a)**2
+ assert trigsimp(eq) == 1
+
+
+def test_issue_5948():
+ a, x, y = symbols('a x y')
+ assert trigsimp(diff(integrate(cos(x)/sin(x)**7, x), x)) == \
+ cos(x)/sin(x)**7
+
+
+def test_issue_4775():
+ a, x, y = symbols('a x y')
+ assert trigsimp(sin(x)*cos(y)+cos(x)*sin(y)) == sin(x + y)
+ assert trigsimp(sin(x)*cos(y)+cos(x)*sin(y)+3) == sin(x + y) + 3
+
+
+def test_issue_4280():
+ a, x, y = symbols('a x y')
+ assert trigsimp(cos(x)**2 + cos(y)**2*sin(x)**2 + sin(y)**2*sin(x)**2) == 1
+ assert trigsimp(a**2*sin(x)**2 + a**2*cos(y)**2*cos(x)**2 + a**2*cos(x)**2*sin(y)**2) == a**2
+ assert trigsimp(a**2*cos(y)**2*sin(x)**2 + a**2*sin(y)**2*sin(x)**2) == a**2*sin(x)**2
+
+
+def test_issue_3210():
+ eqs = (sin(2)*cos(3) + sin(3)*cos(2),
+ -sin(2)*sin(3) + cos(2)*cos(3),
+ sin(2)*cos(3) - sin(3)*cos(2),
+ sin(2)*sin(3) + cos(2)*cos(3),
+ sin(2)*sin(3) + cos(2)*cos(3) + cos(2),
+ sinh(2)*cosh(3) + sinh(3)*cosh(2),
+ sinh(2)*sinh(3) + cosh(2)*cosh(3),
+ )
+ assert [trigsimp(e) for e in eqs] == [
+ sin(5),
+ cos(5),
+ -sin(1),
+ cos(1),
+ cos(1) + cos(2),
+ sinh(5),
+ cosh(5),
+ ]
+
+
+def test_trigsimp_issues():
+ a, x, y = symbols('a x y')
+
+ # issue 4625 - factor_terms works, too
+ assert trigsimp(sin(x)**3 + cos(x)**2*sin(x)) == sin(x)
+
+ # issue 5948
+ assert trigsimp(diff(integrate(cos(x)/sin(x)**3, x), x)) == \
+ cos(x)/sin(x)**3
+ assert trigsimp(diff(integrate(sin(x)/cos(x)**3, x), x)) == \
+ sin(x)/cos(x)**3
+
+ # check integer exponents
+ e = sin(x)**y/cos(x)**y
+ assert trigsimp(e) == e
+ assert trigsimp(e.subs(y, 2)) == tan(x)**2
+ assert trigsimp(e.subs(x, 1)) == tan(1)**y
+
+ # check for multiple patterns
+ assert (cos(x)**2/sin(x)**2*cos(y)**2/sin(y)**2).trigsimp() == \
+ 1/tan(x)**2/tan(y)**2
+ assert trigsimp(cos(x)/sin(x)*cos(x+y)/sin(x+y)) == \
+ 1/(tan(x)*tan(x + y))
+
+ eq = cos(2)*(cos(3) + 1)**2/(cos(3) - 1)**2
+ assert trigsimp(eq) == eq.factor() # factor makes denom (-1 + cos(3))**2
+ assert trigsimp(cos(2)*(cos(3) + 1)**2*(cos(3) - 1)**2) == \
+ cos(2)*sin(3)**4
+
+ # issue 6789; this generates an expression that formerly caused
+ # trigsimp to hang
+ assert cot(x).equals(tan(x)) is False
+
+ # nan or the unchanged expression is ok, but not sin(1)
+ z = cos(x)**2 + sin(x)**2 - 1
+ z1 = tan(x)**2 - 1/cot(x)**2
+ n = (1 + z1/z)
+ assert trigsimp(sin(n)) != sin(1)
+ eq = x*(n - 1) - x*n
+ assert trigsimp(eq) is S.NaN
+ assert trigsimp(eq, recursive=True) is S.NaN
+ assert trigsimp(1).is_Integer
+
+ assert trigsimp(-sin(x)**4 - 2*sin(x)**2*cos(x)**2 - cos(x)**4) == -1
+
+
+def test_trigsimp_issue_2515():
+ x = Symbol('x')
+ assert trigsimp(x*cos(x)*tan(x)) == x*sin(x)
+ assert trigsimp(-sin(x) + cos(x)*tan(x)) == 0
+
+
+def test_trigsimp_issue_3826():
+ assert trigsimp(tan(2*x).expand(trig=True)) == tan(2*x)
+
+
+def test_trigsimp_issue_4032():
+ n = Symbol('n', integer=True, positive=True)
+ assert trigsimp(2**(n/2)*cos(pi*n/4)/2 + 2**(n - 1)/2) == \
+ 2**(n/2)*cos(pi*n/4)/2 + 2**n/4
+
+
+def test_trigsimp_issue_7761():
+ assert trigsimp(cosh(pi/4)) == cosh(pi/4)
+
+
+def test_trigsimp_noncommutative():
+ x, y = symbols('x,y')
+ A, B = symbols('A,B', commutative=False)
+
+ assert trigsimp(A - A*sin(x)**2) == A*cos(x)**2
+ assert trigsimp(A - A*cos(x)**2) == A*sin(x)**2
+ assert trigsimp(A*sin(x)**2 + A*cos(x)**2) == A
+ assert trigsimp(A + A*tan(x)**2) == A/cos(x)**2
+ assert trigsimp(A/cos(x)**2 - A) == A*tan(x)**2
+ assert trigsimp(A/cos(x)**2 - A*tan(x)**2) == A
+ assert trigsimp(A + A*cot(x)**2) == A/sin(x)**2
+ assert trigsimp(A/sin(x)**2 - A) == A/tan(x)**2
+ assert trigsimp(A/sin(x)**2 - A*cot(x)**2) == A
+
+ assert trigsimp(y*A*cos(x)**2 + y*A*sin(x)**2) == y*A
+
+ assert trigsimp(A*sin(x)/cos(x)) == A*tan(x)
+ assert trigsimp(A*tan(x)*cos(x)) == A*sin(x)
+ assert trigsimp(A*cot(x)**3*sin(x)**3) == A*cos(x)**3
+ assert trigsimp(y*A*tan(x)**2/sin(x)**2) == y*A/cos(x)**2
+ assert trigsimp(A*cot(x)/cos(x)) == A/sin(x)
+
+ assert trigsimp(A*sin(x + y) + A*sin(x - y)) == 2*A*sin(x)*cos(y)
+ assert trigsimp(A*sin(x + y) - A*sin(x - y)) == 2*A*sin(y)*cos(x)
+ assert trigsimp(A*cos(x + y) + A*cos(x - y)) == 2*A*cos(x)*cos(y)
+ assert trigsimp(A*cos(x + y) - A*cos(x - y)) == -2*A*sin(x)*sin(y)
+
+ assert trigsimp(A*sinh(x + y) + A*sinh(x - y)) == 2*A*sinh(x)*cosh(y)
+ assert trigsimp(A*sinh(x + y) - A*sinh(x - y)) == 2*A*sinh(y)*cosh(x)
+ assert trigsimp(A*cosh(x + y) + A*cosh(x - y)) == 2*A*cosh(x)*cosh(y)
+ assert trigsimp(A*cosh(x + y) - A*cosh(x - y)) == 2*A*sinh(x)*sinh(y)
+
+ assert trigsimp(A*cos(0.12345)**2 + A*sin(0.12345)**2) == 1.0*A
+
+
+def test_hyperbolic_simp():
+ x, y = symbols('x,y')
+
+ assert trigsimp(sinh(x)**2 + 1) == cosh(x)**2
+ assert trigsimp(cosh(x)**2 - 1) == sinh(x)**2
+ assert trigsimp(cosh(x)**2 - sinh(x)**2) == 1
+ assert trigsimp(1 - tanh(x)**2) == 1/cosh(x)**2
+ assert trigsimp(1 - 1/cosh(x)**2) == tanh(x)**2
+ assert trigsimp(tanh(x)**2 + 1/cosh(x)**2) == 1
+ assert trigsimp(coth(x)**2 - 1) == 1/sinh(x)**2
+ assert trigsimp(1/sinh(x)**2 + 1) == 1/tanh(x)**2
+ assert trigsimp(coth(x)**2 - 1/sinh(x)**2) == 1
+
+ assert trigsimp(5*cosh(x)**2 - 5*sinh(x)**2) == 5
+ assert trigsimp(5*cosh(x/2)**2 - 2*sinh(x/2)**2) == 3*cosh(x)/2 + Rational(7, 2)
+
+ assert trigsimp(sinh(x)/cosh(x)) == tanh(x)
+ assert trigsimp(tanh(x)) == trigsimp(sinh(x)/cosh(x))
+ assert trigsimp(cosh(x)/sinh(x)) == 1/tanh(x)
+ assert trigsimp(2*tanh(x)*cosh(x)) == 2*sinh(x)
+ assert trigsimp(coth(x)**3*sinh(x)**3) == cosh(x)**3
+ assert trigsimp(y*tanh(x)**2/sinh(x)**2) == y/cosh(x)**2
+ assert trigsimp(coth(x)/cosh(x)) == 1/sinh(x)
+
+ for a in (pi/6*I, pi/4*I, pi/3*I):
+ assert trigsimp(sinh(a)*cosh(x) + cosh(a)*sinh(x)) == sinh(x + a)
+ assert trigsimp(-sinh(a)*cosh(x) + cosh(a)*sinh(x)) == sinh(x - a)
+
+ e = 2*cosh(x)**2 - 2*sinh(x)**2
+ assert trigsimp(log(e)) == log(2)
+
+ # issue 19535:
+ assert trigsimp(sqrt(cosh(x)**2 - 1)) == sqrt(sinh(x)**2)
+
+ assert trigsimp(cosh(x)**2*cosh(y)**2 - cosh(x)**2*sinh(y)**2 - sinh(x)**2,
+ recursive=True) == 1
+ assert trigsimp(sinh(x)**2*sinh(y)**2 - sinh(x)**2*cosh(y)**2 + cosh(x)**2,
+ recursive=True) == 1
+
+ assert abs(trigsimp(2.0*cosh(x)**2 - 2.0*sinh(x)**2) - 2.0) < 1e-10
+
+ assert trigsimp(sinh(x)**2/cosh(x)**2) == tanh(x)**2
+ assert trigsimp(sinh(x)**3/cosh(x)**3) == tanh(x)**3
+ assert trigsimp(sinh(x)**10/cosh(x)**10) == tanh(x)**10
+ assert trigsimp(cosh(x)**3/sinh(x)**3) == 1/tanh(x)**3
+
+ assert trigsimp(cosh(x)/sinh(x)) == 1/tanh(x)
+ assert trigsimp(cosh(x)**2/sinh(x)**2) == 1/tanh(x)**2
+ assert trigsimp(cosh(x)**10/sinh(x)**10) == 1/tanh(x)**10
+
+ assert trigsimp(x*cosh(x)*tanh(x)) == x*sinh(x)
+ assert trigsimp(-sinh(x) + cosh(x)*tanh(x)) == 0
+
+ assert tan(x) != 1/cot(x) # cot doesn't auto-simplify
+
+ assert trigsimp(tan(x) - 1/cot(x)) == 0
+ assert trigsimp(3*tanh(x)**7 - 2/coth(x)**7) == tanh(x)**7
+
+
+def test_trigsimp_groebner():
+ from sympy.simplify.trigsimp import trigsimp_groebner
+
+ c = cos(x)
+ s = sin(x)
+ ex = (4*s*c + 12*s + 5*c**3 + 21*c**2 + 23*c + 15)/(
+ -s*c**2 + 2*s*c + 15*s + 7*c**3 + 31*c**2 + 37*c + 21)
+ resnum = (5*s - 5*c + 1)
+ resdenom = (8*s - 6*c)
+ results = [resnum/resdenom, (-resnum)/(-resdenom)]
+ assert trigsimp_groebner(ex) in results
+ assert trigsimp_groebner(s/c, hints=[tan]) == tan(x)
+ assert trigsimp_groebner(c*s) == c*s
+ assert trigsimp((-s + 1)/c + c/(-s + 1),
+ method='groebner') == 2/c
+ assert trigsimp((-s + 1)/c + c/(-s + 1),
+ method='groebner', polynomial=True) == 2/c
+
+ # Test quick=False works
+ assert trigsimp_groebner(ex, hints=[2]) in results
+ assert trigsimp_groebner(ex, hints=[int(2)]) in results
+
+ # test "I"
+ assert trigsimp_groebner(sin(I*x)/cos(I*x), hints=[tanh]) == I*tanh(x)
+
+ # test hyperbolic / sums
+ assert trigsimp_groebner((tanh(x)+tanh(y))/(1+tanh(x)*tanh(y)),
+ hints=[(tanh, x, y)]) == tanh(x + y)
+
+
+def test_issue_2827_trigsimp_methods():
+ measure1 = lambda expr: len(str(expr))
+ measure2 = lambda expr: -count_ops(expr)
+ # Return the most complicated result
+ expr = (x + 1)/(x + sin(x)**2 + cos(x)**2)
+ ans = Matrix([1])
+ M = Matrix([expr])
+ assert trigsimp(M, method='fu', measure=measure1) == ans
+ assert trigsimp(M, method='fu', measure=measure2) != ans
+ # all methods should work with Basic expressions even if they
+ # aren't Expr
+ M = Matrix.eye(1)
+ assert all(trigsimp(M, method=m) == M for m in
+ 'fu matching groebner old'.split())
+ # watch for E in exptrigsimp, not only exp()
+ eq = 1/sqrt(E) + E
+ assert exptrigsimp(eq) == eq
+
+def test_issue_15129_trigsimp_methods():
+ t1 = Matrix([sin(Rational(1, 50)), cos(Rational(1, 50)), 0])
+ t2 = Matrix([sin(Rational(1, 25)), cos(Rational(1, 25)), 0])
+ t3 = Matrix([cos(Rational(1, 25)), sin(Rational(1, 25)), 0])
+ r1 = t1.dot(t2)
+ r2 = t1.dot(t3)
+ assert trigsimp(r1) == cos(Rational(1, 50))
+ assert trigsimp(r2) == sin(Rational(3, 50))
+
+def test_exptrigsimp():
+ def valid(a, b):
+ from sympy.core.random import verify_numerically as tn
+ if not (tn(a, b) and a == b):
+ return False
+ return True
+
+ assert exptrigsimp(exp(x) + exp(-x)) == 2*cosh(x)
+ assert exptrigsimp(exp(x) - exp(-x)) == 2*sinh(x)
+ assert exptrigsimp((2*exp(x)-2*exp(-x))/(exp(x)+exp(-x))) == 2*tanh(x)
+ assert exptrigsimp((2*exp(2*x)-2)/(exp(2*x)+1)) == 2*tanh(x)
+ e = [cos(x) + I*sin(x), cos(x) - I*sin(x),
+ cosh(x) - sinh(x), cosh(x) + sinh(x)]
+ ok = [exp(I*x), exp(-I*x), exp(-x), exp(x)]
+ assert all(valid(i, j) for i, j in zip(
+ [exptrigsimp(ei) for ei in e], ok))
+
+ ue = [cos(x) + sin(x), cos(x) - sin(x),
+ cosh(x) + I*sinh(x), cosh(x) - I*sinh(x)]
+ assert [exptrigsimp(ei) == ei for ei in ue]
+
+ res = []
+ ok = [y*tanh(1), 1/(y*tanh(1)), I*y*tan(1), -I/(y*tan(1)),
+ y*tanh(x), 1/(y*tanh(x)), I*y*tan(x), -I/(y*tan(x)),
+ y*tanh(1 + I), 1/(y*tanh(1 + I))]
+ for a in (1, I, x, I*x, 1 + I):
+ w = exp(a)
+ eq = y*(w - 1/w)/(w + 1/w)
+ res.append(simplify(eq))
+ res.append(simplify(1/eq))
+ assert all(valid(i, j) for i, j in zip(res, ok))
+
+ for a in range(1, 3):
+ w = exp(a)
+ e = w + 1/w
+ s = simplify(e)
+ assert s == exptrigsimp(e)
+ assert valid(s, 2*cosh(a))
+ e = w - 1/w
+ s = simplify(e)
+ assert s == exptrigsimp(e)
+ assert valid(s, 2*sinh(a))
+
+def test_exptrigsimp_noncommutative():
+ a,b = symbols('a b', commutative=False)
+ x = Symbol('x', commutative=True)
+ assert exp(a + x) == exptrigsimp(exp(a)*exp(x))
+ p = exp(a)*exp(b) - exp(b)*exp(a)
+ assert p == exptrigsimp(p) != 0
+
+def test_powsimp_on_numbers():
+ assert 2**(Rational(1, 3) - 2) == 2**Rational(1, 3)/4
+
+
+@XFAIL
+def test_issue_6811_fail():
+ # from doc/src/modules/physics/mechanics/examples.rst, the current `eq`
+ # at Line 576 (in different variables) was formerly the equivalent and
+ # shorter expression given below...it would be nice to get the short one
+ # back again
+ xp, y, x, z = symbols('xp, y, x, z')
+ eq = 4*(-19*sin(x)*y + 5*sin(3*x)*y + 15*cos(2*x)*z - 21*z)*xp/(9*cos(x) - 5*cos(3*x))
+ assert trigsimp(eq) == -2*(2*cos(x)*tan(x)*y + 3*z)*xp/cos(x)
+
+
+def test_Piecewise():
+ e1 = x*(x + y) - y*(x + y)
+ e2 = sin(x)**2 + cos(x)**2
+ e3 = expand((x + y)*y/x)
+ # s1 = simplify(e1)
+ s2 = simplify(e2)
+ # s3 = simplify(e3)
+
+ # trigsimp tries not to touch non-trig containing args
+ assert trigsimp(Piecewise((e1, e3 < e2), (e3, True))) == \
+ Piecewise((e1, e3 < s2), (e3, True))
+
+
+def test_issue_21594():
+ assert simplify(exp(Rational(1,2)) + exp(Rational(-1,2))) == cosh(S.Half)*2
+
+
+def test_trigsimp_old():
+ x, y = symbols('x,y')
+
+ assert trigsimp(1 - sin(x)**2, old=True) == cos(x)**2
+ assert trigsimp(1 - cos(x)**2, old=True) == sin(x)**2
+ assert trigsimp(sin(x)**2 + cos(x)**2, old=True) == 1
+ assert trigsimp(1 + tan(x)**2, old=True) == 1/cos(x)**2
+ assert trigsimp(1/cos(x)**2 - 1, old=True) == tan(x)**2
+ assert trigsimp(1/cos(x)**2 - tan(x)**2, old=True) == 1
+ assert trigsimp(1 + cot(x)**2, old=True) == 1/sin(x)**2
+ assert trigsimp(1/sin(x)**2 - cot(x)**2, old=True) == 1
+
+ assert trigsimp(5*cos(x)**2 + 5*sin(x)**2, old=True) == 5
+
+ assert trigsimp(sin(x)/cos(x), old=True) == tan(x)
+ assert trigsimp(2*tan(x)*cos(x), old=True) == 2*sin(x)
+ assert trigsimp(cot(x)**3*sin(x)**3, old=True) == cos(x)**3
+ assert trigsimp(y*tan(x)**2/sin(x)**2, old=True) == y/cos(x)**2
+ assert trigsimp(cot(x)/cos(x), old=True) == 1/sin(x)
+
+ assert trigsimp(sin(x + y) + sin(x - y), old=True) == 2*sin(x)*cos(y)
+ assert trigsimp(sin(x + y) - sin(x - y), old=True) == 2*sin(y)*cos(x)
+ assert trigsimp(cos(x + y) + cos(x - y), old=True) == 2*cos(x)*cos(y)
+ assert trigsimp(cos(x + y) - cos(x - y), old=True) == -2*sin(x)*sin(y)
+
+ assert trigsimp(sinh(x + y) + sinh(x - y), old=True) == 2*sinh(x)*cosh(y)
+ assert trigsimp(sinh(x + y) - sinh(x - y), old=True) == 2*sinh(y)*cosh(x)
+ assert trigsimp(cosh(x + y) + cosh(x - y), old=True) == 2*cosh(x)*cosh(y)
+ assert trigsimp(cosh(x + y) - cosh(x - y), old=True) == 2*sinh(x)*sinh(y)
+
+ assert trigsimp(cos(0.12345)**2 + sin(0.12345)**2, old=True) == 1.0
+
+ assert trigsimp(sin(x)/cos(x), old=True, method='combined') == tan(x)
+ assert trigsimp(sin(x)/cos(x), old=True, method='groebner') == sin(x)/cos(x)
+ assert trigsimp(sin(x)/cos(x), old=True, method='groebner', hints=[tan]) == tan(x)
+
+ assert trigsimp(1-sin(sin(x)**2+cos(x)**2)**2, old=True, deep=True) == cos(1)**2
+
+
+def test_trigsimp_inverse():
+ alpha = symbols('alpha')
+ s, c = sin(alpha), cos(alpha)
+
+ for finv in [asin, acos, asec, acsc, atan, acot]:
+ f = finv.inverse(None)
+ assert alpha == trigsimp(finv(f(alpha)), inverse=True)
+
+ # test atan2(cos, sin), atan2(sin, cos), etc...
+ for a, b in [[c, s], [s, c]]:
+ for i, j in product([-1, 1], repeat=2):
+ angle = atan2(i*b, j*a)
+ angle_inverted = trigsimp(angle, inverse=True)
+ assert angle_inverted != angle # assures simplification happened
+ assert sin(angle_inverted) == trigsimp(sin(angle))
+ assert cos(angle_inverted) == trigsimp(cos(angle))
diff --git a/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/crv.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/crv.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..01e1b2c8c298d8535df0dfc791b15ed3c4ae1209
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/crv.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/drv_types.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/drv_types.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aef6b072751af5b096553c9aa35bfb46b5b2d827
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/drv_types.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/error_prop.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/error_prop.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..be4156b1bb8d05aa5f112a5c5ec5cdb0e2154f02
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/error_prop.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/joint_rv.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/joint_rv.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eee648321c5cdc0b128d42d5e035f911961ba4cd
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/joint_rv.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/joint_rv_types.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/joint_rv_types.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06f9df77943813a94c39809539198b5dd663e572
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/joint_rv_types.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/matrix_distributions.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/matrix_distributions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f3993f6b0bb3d4fb89ad4d18984cdc5807af71b
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/matrix_distributions.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/random_matrix.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/random_matrix.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1d6a361887a61058eedca807a16ae1a90efc02fb
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/random_matrix.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/random_matrix_models.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/random_matrix_models.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b78cc00853e6be423b3c51c6c91bf5b180d6d6da
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/random_matrix_models.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/stochastic_process_types.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/stochastic_process_types.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7950fd12d5dc0366ff18263a59a38e56b83f372f
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/stochastic_process_types.cpython-310.pyc differ
diff --git a/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/symbolic_multivariate_probability.cpython-310.pyc b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/symbolic_multivariate_probability.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e23778895cf98a87e8f320b6be4ae9d82ccf0423
Binary files /dev/null and b/vllm/lib/python3.10/site-packages/sympy/stats/__pycache__/symbolic_multivariate_probability.cpython-310.pyc differ