diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__init__.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb85d4ff5d53eb44a039a95cfc2fff687322cc76
--- /dev/null
+++ b/llmeval-env/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/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6bdb7955137e081ff6734ece0ca5d7b81a5e19be
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/__init__.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/curve.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/curve.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e22a741969dac23929664a870728160513631a92
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/curve.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/ellipse.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/ellipse.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d910b3c7dbc208c891329cdd5a8e75cf9e378132
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/ellipse.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/entity.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/entity.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..14e1ac54438c7886f8c8662be761c0c634700701
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/entity.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/exceptions.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/exceptions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06e462c282bfc3866833dd5b69c8ba61292879f7
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/exceptions.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/line.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/line.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..110467102d303f9e93459dbd57d079121cdb00d9
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/line.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/parabola.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/parabola.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..11b7542e81987da0a93f39b780c45da4f7fb479d
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/parabola.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/plane.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/plane.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d07200b85a44fa076a7d178f8d133a52f3d7764b
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/plane.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/point.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/point.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7dca5b0745e1a214c9167939376b6c17868a280f
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/point.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/polygon.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/polygon.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44baad7c4af56665a0120ef265d6137b0374f060
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/polygon.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/util.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/util.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8f2cc5065f5fd9b081a88fee1874787dfe29705c
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/__pycache__/util.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/curve.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/curve.py
new file mode 100644
index 0000000000000000000000000000000000000000..c074f22cad79b1261ad44be4ccface972cdd3b82
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/curve.py
@@ -0,0 +1,424 @@
+"""Curves in 2-dimensional Euclidean space.
+
+Contains
+========
+Curve
+
+"""
+
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core import diff
+from sympy.core.containers import Tuple
+from sympy.core.symbol import _symbol
+from sympy.geometry.entity import GeometryEntity, GeometrySet
+from sympy.geometry.point import Point
+from sympy.integrals import integrate
+from sympy.matrices import Matrix, rot_axis3
+from sympy.utilities.iterables import is_sequence
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+class Curve(GeometrySet):
+ """A curve in space.
+
+ A curve is defined by parametric functions for the coordinates, a
+ parameter and the lower and upper bounds for the parameter value.
+
+ Parameters
+ ==========
+
+ function : list of functions
+ limits : 3-tuple
+ Function parameter and lower and upper bounds.
+
+ Attributes
+ ==========
+
+ functions
+ parameter
+ limits
+
+ Raises
+ ======
+
+ ValueError
+ When `functions` are specified incorrectly.
+ When `limits` are specified incorrectly.
+
+ Examples
+ ========
+
+ >>> from sympy import Curve, sin, cos, interpolate
+ >>> from sympy.abc import t, a
+ >>> C = Curve((sin(t), cos(t)), (t, 0, 2))
+ >>> C.functions
+ (sin(t), cos(t))
+ >>> C.limits
+ (t, 0, 2)
+ >>> C.parameter
+ t
+ >>> C = Curve((t, interpolate([1, 4, 9, 16], t)), (t, 0, 1)); C
+ Curve((t, t**2), (t, 0, 1))
+ >>> C.subs(t, 4)
+ Point2D(4, 16)
+ >>> C.arbitrary_point(a)
+ Point2D(a, a**2)
+
+ See Also
+ ========
+
+ sympy.core.function.Function
+ sympy.polys.polyfuncs.interpolate
+
+ """
+
+ def __new__(cls, function, limits):
+ if not is_sequence(function) or len(function) != 2:
+ raise ValueError("Function argument should be (x(t), y(t)) "
+ "but got %s" % str(function))
+ if not is_sequence(limits) or len(limits) != 3:
+ raise ValueError("Limit argument should be (t, tmin, tmax) "
+ "but got %s" % str(limits))
+
+ return GeometryEntity.__new__(cls, Tuple(*function), Tuple(*limits))
+
+ def __call__(self, f):
+ return self.subs(self.parameter, f)
+
+ def _eval_subs(self, old, new):
+ if old == self.parameter:
+ return Point(*[f.subs(old, new) for f in self.functions])
+
+ def _eval_evalf(self, prec=15, **options):
+ f, (t, a, b) = self.args
+ dps = prec_to_dps(prec)
+ f = tuple([i.evalf(n=dps, **options) for i in f])
+ a, b = [i.evalf(n=dps, **options) for i in (a, b)]
+ return self.func(f, (t, a, b))
+
+ def arbitrary_point(self, parameter='t'):
+ """A parameterized point on the curve.
+
+ Parameters
+ ==========
+
+ parameter : str or Symbol, optional
+ Default value is 't'.
+ The Curve's parameter is selected with None or self.parameter
+ otherwise the provided symbol is used.
+
+ Returns
+ =======
+
+ Point :
+ Returns a point in parametric form.
+
+ Raises
+ ======
+
+ ValueError
+ When `parameter` already appears in the functions.
+
+ Examples
+ ========
+
+ >>> from sympy import Curve, Symbol
+ >>> from sympy.abc import s
+ >>> C = Curve([2*s, s**2], (s, 0, 2))
+ >>> C.arbitrary_point()
+ Point2D(2*t, t**2)
+ >>> C.arbitrary_point(C.parameter)
+ Point2D(2*s, s**2)
+ >>> C.arbitrary_point(None)
+ Point2D(2*s, s**2)
+ >>> C.arbitrary_point(Symbol('a'))
+ Point2D(2*a, a**2)
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ """
+ if parameter is None:
+ return Point(*self.functions)
+
+ tnew = _symbol(parameter, self.parameter, real=True)
+ t = self.parameter
+ if (tnew.name != t.name and
+ tnew.name in (f.name for f in self.free_symbols)):
+ raise ValueError('Symbol %s already appears in object '
+ 'and cannot be used as a parameter.' % tnew.name)
+ return Point(*[w.subs(t, tnew) for w in self.functions])
+
+ @property
+ def free_symbols(self):
+ """Return a set of symbols other than the bound symbols used to
+ parametrically define the Curve.
+
+ Returns
+ =======
+
+ set :
+ Set of all non-parameterized symbols.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import t, a
+ >>> from sympy import Curve
+ >>> Curve((t, t**2), (t, 0, 2)).free_symbols
+ set()
+ >>> Curve((t, t**2), (t, a, 2)).free_symbols
+ {a}
+
+ """
+ free = set()
+ for a in self.functions + self.limits[1:]:
+ free |= a.free_symbols
+ free = free.difference({self.parameter})
+ return free
+
+ @property
+ def ambient_dimension(self):
+ """The dimension of the curve.
+
+ Returns
+ =======
+
+ int :
+ the dimension of curve.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import t
+ >>> from sympy import Curve
+ >>> C = Curve((t, t**2), (t, 0, 2))
+ >>> C.ambient_dimension
+ 2
+
+ """
+
+ return len(self.args[0])
+
+ @property
+ def functions(self):
+ """The functions specifying the curve.
+
+ Returns
+ =======
+
+ functions :
+ list of parameterized coordinate functions.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import t
+ >>> from sympy import Curve
+ >>> C = Curve((t, t**2), (t, 0, 2))
+ >>> C.functions
+ (t, t**2)
+
+ See Also
+ ========
+
+ parameter
+
+ """
+ return self.args[0]
+
+ @property
+ def limits(self):
+ """The limits for the curve.
+
+ Returns
+ =======
+
+ limits : tuple
+ Contains parameter and lower and upper limits.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import t
+ >>> from sympy import Curve
+ >>> C = Curve([t, t**3], (t, -2, 2))
+ >>> C.limits
+ (t, -2, 2)
+
+ See Also
+ ========
+
+ plot_interval
+
+ """
+ return self.args[1]
+
+ @property
+ def parameter(self):
+ """The curve function variable.
+
+ Returns
+ =======
+
+ Symbol :
+ returns a bound symbol.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import t
+ >>> from sympy import Curve
+ >>> C = Curve([t, t**2], (t, 0, 2))
+ >>> C.parameter
+ t
+
+ See Also
+ ========
+
+ functions
+
+ """
+ return self.args[1][0]
+
+ @property
+ def length(self):
+ """The curve length.
+
+ Examples
+ ========
+
+ >>> from sympy import Curve
+ >>> from sympy.abc import t
+ >>> Curve((t, t), (t, 0, 1)).length
+ sqrt(2)
+
+ """
+ integrand = sqrt(sum(diff(func, self.limits[0])**2 for func in self.functions))
+ return integrate(integrand, self.limits)
+
+ def plot_interval(self, parameter='t'):
+ """The plot interval for the default geometric plot of the curve.
+
+ Parameters
+ ==========
+
+ parameter : str or Symbol, optional
+ Default value is 't';
+ otherwise the provided symbol is used.
+
+ Returns
+ =======
+
+ List :
+ the plot interval as below:
+ [parameter, lower_bound, upper_bound]
+
+ Examples
+ ========
+
+ >>> from sympy import Curve, sin
+ >>> from sympy.abc import x, s
+ >>> Curve((x, sin(x)), (x, 1, 2)).plot_interval()
+ [t, 1, 2]
+ >>> Curve((x, sin(x)), (x, 1, 2)).plot_interval(s)
+ [s, 1, 2]
+
+ See Also
+ ========
+
+ limits : Returns limits of the parameter interval
+
+ """
+ t = _symbol(parameter, self.parameter, real=True)
+ return [t] + list(self.limits[1:])
+
+ def rotate(self, angle=0, pt=None):
+ """This function is used to rotate a curve along given point ``pt`` at given angle(in radian).
+
+ Parameters
+ ==========
+
+ angle :
+ the angle at which the curve will be rotated(in radian) in counterclockwise direction.
+ default value of angle is 0.
+
+ pt : Point
+ the point along which the curve will be rotated.
+ If no point given, the curve will be rotated around origin.
+
+ Returns
+ =======
+
+ Curve :
+ returns a curve rotated at given angle along given point.
+
+ Examples
+ ========
+
+ >>> from sympy import Curve, pi
+ >>> from sympy.abc import x
+ >>> Curve((x, x), (x, 0, 1)).rotate(pi/2)
+ Curve((-x, x), (x, 0, 1))
+
+ """
+ if pt:
+ pt = -Point(pt, dim=2)
+ else:
+ pt = Point(0,0)
+ rv = self.translate(*pt.args)
+ f = list(rv.functions)
+ f.append(0)
+ f = Matrix(1, 3, f)
+ f *= rot_axis3(angle)
+ rv = self.func(f[0, :2].tolist()[0], self.limits)
+ pt = -pt
+ return rv.translate(*pt.args)
+
+ def scale(self, x=1, y=1, pt=None):
+ """Override GeometryEntity.scale since Curve is not made up of Points.
+
+ Returns
+ =======
+
+ Curve :
+ returns scaled curve.
+
+ Examples
+ ========
+
+ >>> from sympy import Curve
+ >>> from sympy.abc import x
+ >>> Curve((x, x), (x, 0, 1)).scale(2)
+ Curve((2*x, x), (x, 0, 1))
+
+ """
+ if pt:
+ pt = Point(pt, dim=2)
+ return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+ fx, fy = self.functions
+ return self.func((fx*x, fy*y), self.limits)
+
+ def translate(self, x=0, y=0):
+ """Translate the Curve by (x, y).
+
+ Returns
+ =======
+
+ Curve :
+ returns a translated curve.
+
+ Examples
+ ========
+
+ >>> from sympy import Curve
+ >>> from sympy.abc import x
+ >>> Curve((x, x), (x, 0, 1)).translate(1, 2)
+ Curve((x + 1, x + 2), (x, 0, 1))
+
+ """
+ fx, fy = self.functions
+ return self.func((fx + x, fy + y), self.limits)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/ellipse.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/ellipse.py
new file mode 100644
index 0000000000000000000000000000000000000000..e191ee694211eabae51e9706b9bc65df9ad0ba78
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/ellipse.py
@@ -0,0 +1,1780 @@
+"""Elliptical geometrical entities.
+
+Contains
+* Ellipse
+* Circle
+
+"""
+
+from sympy.core.expr import Expr
+from sympy.core.relational import Eq
+from sympy.core import S, pi, sympify
+from sympy.core.evalf import N
+from sympy.core.parameters import global_parameters
+from sympy.core.logic import fuzzy_bool
+from sympy.core.numbers import Rational, oo
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy, uniquely_named_symbol, _symbol
+from sympy.simplify import simplify, trigsimp
+from sympy.functions.elementary.miscellaneous import sqrt, Max
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.functions.special.elliptic_integrals import elliptic_e
+from .entity import GeometryEntity, GeometrySet
+from .exceptions import GeometryError
+from .line import Line, Segment, Ray2D, Segment2D, Line2D, LinearEntity3D
+from .point import Point, Point2D, Point3D
+from .util import idiff, find
+from sympy.polys import DomainError, Poly, PolynomialError
+from sympy.polys.polyutils import _not_a_coeff, _nsort
+from sympy.solvers import solve
+from sympy.solvers.solveset import linear_coeffs
+from sympy.utilities.misc import filldedent, func_name
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+import random
+
+x, y = [Dummy('ellipse_dummy', real=True) for i in range(2)]
+
+
+class Ellipse(GeometrySet):
+ """An elliptical GeometryEntity.
+
+ Parameters
+ ==========
+
+ center : Point, optional
+ Default value is Point(0, 0)
+ hradius : number or SymPy expression, optional
+ vradius : number or SymPy expression, optional
+ eccentricity : number or SymPy expression, optional
+ Two of `hradius`, `vradius` and `eccentricity` must be supplied to
+ create an Ellipse. The third is derived from the two supplied.
+
+ Attributes
+ ==========
+
+ center
+ hradius
+ vradius
+ area
+ circumference
+ eccentricity
+ periapsis
+ apoapsis
+ focus_distance
+ foci
+
+ Raises
+ ======
+
+ GeometryError
+ When `hradius`, `vradius` and `eccentricity` are incorrectly supplied
+ as parameters.
+ TypeError
+ When `center` is not a Point.
+
+ See Also
+ ========
+
+ Circle
+
+ Notes
+ -----
+ Constructed from a center and two radii, the first being the horizontal
+ radius (along the x-axis) and the second being the vertical radius (along
+ the y-axis).
+
+ When symbolic value for hradius and vradius are used, any calculation that
+ refers to the foci or the major or minor axis will assume that the ellipse
+ has its major radius on the x-axis. If this is not true then a manual
+ rotation is necessary.
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse, Point, Rational
+ >>> e1 = Ellipse(Point(0, 0), 5, 1)
+ >>> e1.hradius, e1.vradius
+ (5, 1)
+ >>> e2 = Ellipse(Point(3, 1), hradius=3, eccentricity=Rational(4, 5))
+ >>> e2
+ Ellipse(Point2D(3, 1), 3, 9/5)
+
+ """
+
+ def __contains__(self, o):
+ if isinstance(o, Point):
+ res = self.equation(x, y).subs({x: o.x, y: o.y})
+ return trigsimp(simplify(res)) is S.Zero
+ elif isinstance(o, Ellipse):
+ return self == o
+ return False
+
+ def __eq__(self, o):
+ """Is the other GeometryEntity the same as this ellipse?"""
+ return isinstance(o, Ellipse) and (self.center == o.center and
+ self.hradius == o.hradius and
+ self.vradius == o.vradius)
+
+ def __hash__(self):
+ return super().__hash__()
+
+ def __new__(
+ cls, center=None, hradius=None, vradius=None, eccentricity=None, **kwargs):
+
+ hradius = sympify(hradius)
+ vradius = sympify(vradius)
+
+ if center is None:
+ center = Point(0, 0)
+ else:
+ if len(center) != 2:
+ raise ValueError('The center of "{}" must be a two dimensional point'.format(cls))
+ center = Point(center, dim=2)
+
+ if len(list(filter(lambda x: x is not None, (hradius, vradius, eccentricity)))) != 2:
+ raise ValueError(filldedent('''
+ Exactly two arguments of "hradius", "vradius", and
+ "eccentricity" must not be None.'''))
+
+ if eccentricity is not None:
+ eccentricity = sympify(eccentricity)
+ if eccentricity.is_negative:
+ raise GeometryError("Eccentricity of ellipse/circle should lie between [0, 1)")
+ elif hradius is None:
+ hradius = vradius / sqrt(1 - eccentricity**2)
+ elif vradius is None:
+ vradius = hradius * sqrt(1 - eccentricity**2)
+
+ if hradius == vradius:
+ return Circle(center, hradius, **kwargs)
+
+ if S.Zero in (hradius, vradius):
+ return Segment(Point(center[0] - hradius, center[1] - vradius), Point(center[0] + hradius, center[1] + vradius))
+
+ if hradius.is_real is False or vradius.is_real is False:
+ raise GeometryError("Invalid value encountered when computing hradius / vradius.")
+
+ return GeometryEntity.__new__(cls, center, hradius, vradius, **kwargs)
+
+ def _svg(self, scale_factor=1., fill_color="#66cc99"):
+ """Returns SVG ellipse element for the Ellipse.
+
+ Parameters
+ ==========
+
+ scale_factor : float
+ Multiplication factor for the SVG stroke-width. Default is 1.
+ fill_color : str, optional
+ Hex string for fill color. Default is "#66cc99".
+ """
+
+ c = N(self.center)
+ h, v = N(self.hradius), N(self.vradius)
+ return (
+ ''
+ ).format(2. * scale_factor, fill_color, c.x, c.y, h, v)
+
+ @property
+ def ambient_dimension(self):
+ return 2
+
+ @property
+ def apoapsis(self):
+ """The apoapsis of the ellipse.
+
+ The greatest distance between the focus and the contour.
+
+ Returns
+ =======
+
+ apoapsis : number
+
+ See Also
+ ========
+
+ periapsis : Returns shortest distance between foci and contour
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.apoapsis
+ 2*sqrt(2) + 3
+
+ """
+ return self.major * (1 + self.eccentricity)
+
+ def arbitrary_point(self, parameter='t'):
+ """A parameterized point on the ellipse.
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ Default value is 't'.
+
+ Returns
+ =======
+
+ arbitrary_point : Point
+
+ Raises
+ ======
+
+ ValueError
+ When `parameter` already appears in the functions.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> e1 = Ellipse(Point(0, 0), 3, 2)
+ >>> e1.arbitrary_point()
+ Point2D(3*cos(t), 2*sin(t))
+
+ """
+ t = _symbol(parameter, real=True)
+ if t.name in (f.name for f in self.free_symbols):
+ raise ValueError(filldedent('Symbol %s already appears in object '
+ 'and cannot be used as a parameter.' % t.name))
+ return Point(self.center.x + self.hradius*cos(t),
+ self.center.y + self.vradius*sin(t))
+
+ @property
+ def area(self):
+ """The area of the ellipse.
+
+ Returns
+ =======
+
+ area : number
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.area
+ 3*pi
+
+ """
+ return simplify(S.Pi * self.hradius * self.vradius)
+
+ @property
+ def bounds(self):
+ """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+ rectangle for the geometric figure.
+
+ """
+
+ h, v = self.hradius, self.vradius
+ return (self.center.x - h, self.center.y - v, self.center.x + h, self.center.y + v)
+
+ @property
+ def center(self):
+ """The center of the ellipse.
+
+ Returns
+ =======
+
+ center : number
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.center
+ Point2D(0, 0)
+
+ """
+ return self.args[0]
+
+ @property
+ def circumference(self):
+ """The circumference of the ellipse.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.circumference
+ 12*elliptic_e(8/9)
+
+ """
+ if self.eccentricity == 1:
+ # degenerate
+ return 4*self.major
+ elif self.eccentricity == 0:
+ # circle
+ return 2*pi*self.hradius
+ else:
+ return 4*self.major*elliptic_e(self.eccentricity**2)
+
+ @property
+ def eccentricity(self):
+ """The eccentricity of the ellipse.
+
+ Returns
+ =======
+
+ eccentricity : number
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse, sqrt
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, sqrt(2))
+ >>> e1.eccentricity
+ sqrt(7)/3
+
+ """
+ return self.focus_distance / self.major
+
+ def encloses_point(self, p):
+ """
+ Return True if p is enclosed by (is inside of) self.
+
+ Notes
+ -----
+ Being on the border of self is considered False.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ encloses_point : True, False or None
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse, S
+ >>> from sympy.abc import t
+ >>> e = Ellipse((0, 0), 3, 2)
+ >>> e.encloses_point((0, 0))
+ True
+ >>> e.encloses_point(e.arbitrary_point(t).subs(t, S.Half))
+ False
+ >>> e.encloses_point((4, 0))
+ False
+
+ """
+ p = Point(p, dim=2)
+ if p in self:
+ return False
+
+ if len(self.foci) == 2:
+ # if the combined distance from the foci to p (h1 + h2) is less
+ # than the combined distance from the foci to the minor axis
+ # (which is the same as the major axis length) then p is inside
+ # the ellipse
+ h1, h2 = [f.distance(p) for f in self.foci]
+ test = 2*self.major - (h1 + h2)
+ else:
+ test = self.radius - self.center.distance(p)
+
+ return fuzzy_bool(test.is_positive)
+
+ def equation(self, x='x', y='y', _slope=None):
+ """
+ Returns the equation of an ellipse aligned with the x and y axes;
+ when slope is given, the equation returned corresponds to an ellipse
+ with a major axis having that slope.
+
+ Parameters
+ ==========
+
+ x : str, optional
+ Label for the x-axis. Default value is 'x'.
+ y : str, optional
+ Label for the y-axis. Default value is 'y'.
+ _slope : Expr, optional
+ The slope of the major axis. Ignored when 'None'.
+
+ Returns
+ =======
+
+ equation : SymPy expression
+
+ See Also
+ ========
+
+ arbitrary_point : Returns parameterized point on ellipse
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse, pi
+ >>> from sympy.abc import x, y
+ >>> e1 = Ellipse(Point(1, 0), 3, 2)
+ >>> eq1 = e1.equation(x, y); eq1
+ y**2/4 + (x/3 - 1/3)**2 - 1
+ >>> eq2 = e1.equation(x, y, _slope=1); eq2
+ (-x + y + 1)**2/8 + (x + y - 1)**2/18 - 1
+
+ A point on e1 satisfies eq1. Let's use one on the x-axis:
+
+ >>> p1 = e1.center + Point(e1.major, 0)
+ >>> assert eq1.subs(x, p1.x).subs(y, p1.y) == 0
+
+ When rotated the same as the rotated ellipse, about the center
+ point of the ellipse, it will satisfy the rotated ellipse's
+ equation, too:
+
+ >>> r1 = p1.rotate(pi/4, e1.center)
+ >>> assert eq2.subs(x, r1.x).subs(y, r1.y) == 0
+
+ References
+ ==========
+
+ .. [1] https://math.stackexchange.com/questions/108270/what-is-the-equation-of-an-ellipse-that-is-not-aligned-with-the-axis
+ .. [2] https://en.wikipedia.org/wiki/Ellipse#Shifted_ellipse
+
+ """
+
+ x = _symbol(x, real=True)
+ y = _symbol(y, real=True)
+
+ dx = x - self.center.x
+ dy = y - self.center.y
+
+ if _slope is not None:
+ L = (dy - _slope*dx)**2
+ l = (_slope*dy + dx)**2
+ h = 1 + _slope**2
+ b = h*self.major**2
+ a = h*self.minor**2
+ return l/b + L/a - 1
+
+ else:
+ t1 = (dx/self.hradius)**2
+ t2 = (dy/self.vradius)**2
+ return t1 + t2 - 1
+
+ def evolute(self, x='x', y='y'):
+ """The equation of evolute of the ellipse.
+
+ Parameters
+ ==========
+
+ x : str, optional
+ Label for the x-axis. Default value is 'x'.
+ y : str, optional
+ Label for the y-axis. Default value is 'y'.
+
+ Returns
+ =======
+
+ equation : SymPy expression
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> e1 = Ellipse(Point(1, 0), 3, 2)
+ >>> e1.evolute()
+ 2**(2/3)*y**(2/3) + (3*x - 3)**(2/3) - 5**(2/3)
+ """
+ if len(self.args) != 3:
+ raise NotImplementedError('Evolute of arbitrary Ellipse is not supported.')
+ x = _symbol(x, real=True)
+ y = _symbol(y, real=True)
+ t1 = (self.hradius*(x - self.center.x))**Rational(2, 3)
+ t2 = (self.vradius*(y - self.center.y))**Rational(2, 3)
+ return t1 + t2 - (self.hradius**2 - self.vradius**2)**Rational(2, 3)
+
+ @property
+ def foci(self):
+ """The foci of the ellipse.
+
+ Notes
+ -----
+ The foci can only be calculated if the major/minor axes are known.
+
+ Raises
+ ======
+
+ ValueError
+ When the major and minor axis cannot be determined.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+ focus_distance : Returns the distance between focus and center
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.foci
+ (Point2D(-2*sqrt(2), 0), Point2D(2*sqrt(2), 0))
+
+ """
+ c = self.center
+ hr, vr = self.hradius, self.vradius
+ if hr == vr:
+ return (c, c)
+
+ # calculate focus distance manually, since focus_distance calls this
+ # routine
+ fd = sqrt(self.major**2 - self.minor**2)
+ if hr == self.minor:
+ # foci on the y-axis
+ return (c + Point(0, -fd), c + Point(0, fd))
+ elif hr == self.major:
+ # foci on the x-axis
+ return (c + Point(-fd, 0), c + Point(fd, 0))
+
+ @property
+ def focus_distance(self):
+ """The focal distance of the ellipse.
+
+ The distance between the center and one focus.
+
+ Returns
+ =======
+
+ focus_distance : number
+
+ See Also
+ ========
+
+ foci
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.focus_distance
+ 2*sqrt(2)
+
+ """
+ return Point.distance(self.center, self.foci[0])
+
+ @property
+ def hradius(self):
+ """The horizontal radius of the ellipse.
+
+ Returns
+ =======
+
+ hradius : number
+
+ See Also
+ ========
+
+ vradius, major, minor
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.hradius
+ 3
+
+ """
+ return self.args[1]
+
+ def intersection(self, o):
+ """The intersection of this ellipse and another geometrical entity
+ `o`.
+
+ Parameters
+ ==========
+
+ o : GeometryEntity
+
+ Returns
+ =======
+
+ intersection : list of GeometryEntity objects
+
+ Notes
+ -----
+ Currently supports intersections with Point, Line, Segment, Ray,
+ Circle and Ellipse types.
+
+ See Also
+ ========
+
+ sympy.geometry.entity.GeometryEntity
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse, Point, Line
+ >>> e = Ellipse(Point(0, 0), 5, 7)
+ >>> e.intersection(Point(0, 0))
+ []
+ >>> e.intersection(Point(5, 0))
+ [Point2D(5, 0)]
+ >>> e.intersection(Line(Point(0,0), Point(0, 1)))
+ [Point2D(0, -7), Point2D(0, 7)]
+ >>> e.intersection(Line(Point(5,0), Point(5, 1)))
+ [Point2D(5, 0)]
+ >>> e.intersection(Line(Point(6,0), Point(6, 1)))
+ []
+ >>> e = Ellipse(Point(-1, 0), 4, 3)
+ >>> e.intersection(Ellipse(Point(1, 0), 4, 3))
+ [Point2D(0, -3*sqrt(15)/4), Point2D(0, 3*sqrt(15)/4)]
+ >>> e.intersection(Ellipse(Point(5, 0), 4, 3))
+ [Point2D(2, -3*sqrt(7)/4), Point2D(2, 3*sqrt(7)/4)]
+ >>> e.intersection(Ellipse(Point(100500, 0), 4, 3))
+ []
+ >>> e.intersection(Ellipse(Point(0, 0), 3, 4))
+ [Point2D(3, 0), Point2D(-363/175, -48*sqrt(111)/175), Point2D(-363/175, 48*sqrt(111)/175)]
+ >>> e.intersection(Ellipse(Point(-1, 0), 3, 4))
+ [Point2D(-17/5, -12/5), Point2D(-17/5, 12/5), Point2D(7/5, -12/5), Point2D(7/5, 12/5)]
+ """
+ # TODO: Replace solve with nonlinsolve, when nonlinsolve will be able to solve in real domain
+
+ if isinstance(o, Point):
+ if o in self:
+ return [o]
+ else:
+ return []
+
+ elif isinstance(o, (Segment2D, Ray2D)):
+ ellipse_equation = self.equation(x, y)
+ result = solve([ellipse_equation, Line(
+ o.points[0], o.points[1]).equation(x, y)], [x, y],
+ set=True)[1]
+ return list(ordered([Point(i) for i in result if i in o]))
+
+ elif isinstance(o, Polygon):
+ return o.intersection(self)
+
+ elif isinstance(o, (Ellipse, Line2D)):
+ if o == self:
+ return self
+ else:
+ ellipse_equation = self.equation(x, y)
+ return list(ordered([Point(i) for i in solve(
+ [ellipse_equation, o.equation(x, y)], [x, y],
+ set=True)[1]]))
+ elif isinstance(o, LinearEntity3D):
+ raise TypeError('Entity must be two dimensional, not three dimensional')
+ else:
+ raise TypeError('Intersection not handled for %s' % func_name(o))
+
+ def is_tangent(self, o):
+ """Is `o` tangent to the ellipse?
+
+ Parameters
+ ==========
+
+ o : GeometryEntity
+ An Ellipse, LinearEntity or Polygon
+
+ Raises
+ ======
+
+ NotImplementedError
+ When the wrong type of argument is supplied.
+
+ Returns
+ =======
+
+ is_tangent: boolean
+ True if o is tangent to the ellipse, False otherwise.
+
+ See Also
+ ========
+
+ tangent_lines
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse, Line
+ >>> p0, p1, p2 = Point(0, 0), Point(3, 0), Point(3, 3)
+ >>> e1 = Ellipse(p0, 3, 2)
+ >>> l1 = Line(p1, p2)
+ >>> e1.is_tangent(l1)
+ True
+
+ """
+ if isinstance(o, Point2D):
+ return False
+ elif isinstance(o, Ellipse):
+ intersect = self.intersection(o)
+ if isinstance(intersect, Ellipse):
+ return True
+ elif intersect:
+ return all((self.tangent_lines(i)[0]).equals(o.tangent_lines(i)[0]) for i in intersect)
+ else:
+ return False
+ elif isinstance(o, Line2D):
+ hit = self.intersection(o)
+ if not hit:
+ return False
+ if len(hit) == 1:
+ return True
+ # might return None if it can't decide
+ return hit[0].equals(hit[1])
+ elif isinstance(o, Ray2D):
+ intersect = self.intersection(o)
+ if len(intersect) == 1:
+ return intersect[0] != o.source and not self.encloses_point(o.source)
+ else:
+ return False
+ elif isinstance(o, (Segment2D, Polygon)):
+ all_tangents = False
+ segments = o.sides if isinstance(o, Polygon) else [o]
+ for segment in segments:
+ intersect = self.intersection(segment)
+ if len(intersect) == 1:
+ if not any(intersect[0] in i for i in segment.points) \
+ and not any(self.encloses_point(i) for i in segment.points):
+ all_tangents = True
+ continue
+ else:
+ return False
+ else:
+ return all_tangents
+ return all_tangents
+ elif isinstance(o, (LinearEntity3D, Point3D)):
+ raise TypeError('Entity must be two dimensional, not three dimensional')
+ else:
+ raise TypeError('Is_tangent not handled for %s' % func_name(o))
+
+ @property
+ def major(self):
+ """Longer axis of the ellipse (if it can be determined) else hradius.
+
+ Returns
+ =======
+
+ major : number or expression
+
+ See Also
+ ========
+
+ hradius, vradius, minor
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse, Symbol
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.major
+ 3
+
+ >>> a = Symbol('a')
+ >>> b = Symbol('b')
+ >>> Ellipse(p1, a, b).major
+ a
+ >>> Ellipse(p1, b, a).major
+ b
+
+ >>> m = Symbol('m')
+ >>> M = m + 1
+ >>> Ellipse(p1, m, M).major
+ m + 1
+
+ """
+ ab = self.args[1:3]
+ if len(ab) == 1:
+ return ab[0]
+ a, b = ab
+ o = b - a < 0
+ if o == True:
+ return a
+ elif o == False:
+ return b
+ return self.hradius
+
+ @property
+ def minor(self):
+ """Shorter axis of the ellipse (if it can be determined) else vradius.
+
+ Returns
+ =======
+
+ minor : number or expression
+
+ See Also
+ ========
+
+ hradius, vradius, major
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse, Symbol
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.minor
+ 1
+
+ >>> a = Symbol('a')
+ >>> b = Symbol('b')
+ >>> Ellipse(p1, a, b).minor
+ b
+ >>> Ellipse(p1, b, a).minor
+ a
+
+ >>> m = Symbol('m')
+ >>> M = m + 1
+ >>> Ellipse(p1, m, M).minor
+ m
+
+ """
+ ab = self.args[1:3]
+ if len(ab) == 1:
+ return ab[0]
+ a, b = ab
+ o = a - b < 0
+ if o == True:
+ return a
+ elif o == False:
+ return b
+ return self.vradius
+
+ def normal_lines(self, p, prec=None):
+ """Normal lines between `p` and the ellipse.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ normal_lines : list with 1, 2 or 4 Lines
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> e = Ellipse((0, 0), 2, 3)
+ >>> c = e.center
+ >>> e.normal_lines(c + Point(1, 0))
+ [Line2D(Point2D(0, 0), Point2D(1, 0))]
+ >>> e.normal_lines(c)
+ [Line2D(Point2D(0, 0), Point2D(0, 1)), Line2D(Point2D(0, 0), Point2D(1, 0))]
+
+ Off-axis points require the solution of a quartic equation. This
+ often leads to very large expressions that may be of little practical
+ use. An approximate solution of `prec` digits can be obtained by
+ passing in the desired value:
+
+ >>> e.normal_lines((3, 3), prec=2)
+ [Line2D(Point2D(-0.81, -2.7), Point2D(0.19, -1.2)),
+ Line2D(Point2D(1.5, -2.0), Point2D(2.5, -2.7))]
+
+ Whereas the above solution has an operation count of 12, the exact
+ solution has an operation count of 2020.
+ """
+ p = Point(p, dim=2)
+
+ # XXX change True to something like self.angle == 0 if the arbitrarily
+ # rotated ellipse is introduced.
+ # https://github.com/sympy/sympy/issues/2815)
+ if True:
+ rv = []
+ if p.x == self.center.x:
+ rv.append(Line(self.center, slope=oo))
+ if p.y == self.center.y:
+ rv.append(Line(self.center, slope=0))
+ if rv:
+ # at these special orientations of p either 1 or 2 normals
+ # exist and we are done
+ return rv
+
+ # find the 4 normal points and construct lines through them with
+ # the corresponding slope
+ eq = self.equation(x, y)
+ dydx = idiff(eq, y, x)
+ norm = -1/dydx
+ slope = Line(p, (x, y)).slope
+ seq = slope - norm
+
+ # TODO: Replace solve with solveset, when this line is tested
+ yis = solve(seq, y)[0]
+ xeq = eq.subs(y, yis).as_numer_denom()[0].expand()
+ if len(xeq.free_symbols) == 1:
+ try:
+ # this is so much faster, it's worth a try
+ xsol = Poly(xeq, x).real_roots()
+ except (DomainError, PolynomialError, NotImplementedError):
+ # TODO: Replace solve with solveset, when these lines are tested
+ xsol = _nsort(solve(xeq, x), separated=True)[0]
+ points = [Point(i, solve(eq.subs(x, i), y)[0]) for i in xsol]
+ else:
+ raise NotImplementedError(
+ 'intersections for the general ellipse are not supported')
+ slopes = [norm.subs(zip((x, y), pt.args)) for pt in points]
+ if prec is not None:
+ points = [pt.n(prec) for pt in points]
+ slopes = [i if _not_a_coeff(i) else i.n(prec) for i in slopes]
+ return [Line(pt, slope=s) for pt, s in zip(points, slopes)]
+
+ @property
+ def periapsis(self):
+ """The periapsis of the ellipse.
+
+ The shortest distance between the focus and the contour.
+
+ Returns
+ =======
+
+ periapsis : number
+
+ See Also
+ ========
+
+ apoapsis : Returns greatest distance between focus and contour
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.periapsis
+ 3 - 2*sqrt(2)
+
+ """
+ return self.major * (1 - self.eccentricity)
+
+ @property
+ def semilatus_rectum(self):
+ """
+ Calculates the semi-latus rectum of the Ellipse.
+
+ Semi-latus rectum is defined as one half of the chord through a
+ focus parallel to the conic section directrix of a conic section.
+
+ Returns
+ =======
+
+ semilatus_rectum : number
+
+ See Also
+ ========
+
+ apoapsis : Returns greatest distance between focus and contour
+
+ periapsis : The shortest distance between the focus and the contour
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.semilatus_rectum
+ 1/3
+
+ References
+ ==========
+
+ .. [1] https://mathworld.wolfram.com/SemilatusRectum.html
+ .. [2] https://en.wikipedia.org/wiki/Ellipse#Semi-latus_rectum
+
+ """
+ return self.major * (1 - self.eccentricity ** 2)
+
+ def auxiliary_circle(self):
+ """Returns a Circle whose diameter is the major axis of the ellipse.
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse, Point, symbols
+ >>> c = Point(1, 2)
+ >>> Ellipse(c, 8, 7).auxiliary_circle()
+ Circle(Point2D(1, 2), 8)
+ >>> a, b = symbols('a b')
+ >>> Ellipse(c, a, b).auxiliary_circle()
+ Circle(Point2D(1, 2), Max(a, b))
+ """
+ return Circle(self.center, Max(self.hradius, self.vradius))
+
+ def director_circle(self):
+ """
+ Returns a Circle consisting of all points where two perpendicular
+ tangent lines to the ellipse cross each other.
+
+ Returns
+ =======
+
+ Circle
+ A director circle returned as a geometric object.
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse, Point, symbols
+ >>> c = Point(3,8)
+ >>> Ellipse(c, 7, 9).director_circle()
+ Circle(Point2D(3, 8), sqrt(130))
+ >>> a, b = symbols('a b')
+ >>> Ellipse(c, a, b).director_circle()
+ Circle(Point2D(3, 8), sqrt(a**2 + b**2))
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Director_circle
+
+ """
+ return Circle(self.center, sqrt(self.hradius**2 + self.vradius**2))
+
+ def plot_interval(self, parameter='t'):
+ """The plot interval for the default geometric plot of the Ellipse.
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ Default value is 't'.
+
+ Returns
+ =======
+
+ plot_interval : list
+ [parameter, lower_bound, upper_bound]
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> e1 = Ellipse(Point(0, 0), 3, 2)
+ >>> e1.plot_interval()
+ [t, -pi, pi]
+
+ """
+ t = _symbol(parameter, real=True)
+ return [t, -S.Pi, S.Pi]
+
+ def random_point(self, seed=None):
+ """A random point on the ellipse.
+
+ Returns
+ =======
+
+ point : Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> e1 = Ellipse(Point(0, 0), 3, 2)
+ >>> e1.random_point() # gives some random point
+ Point2D(...)
+ >>> p1 = e1.random_point(seed=0); p1.n(2)
+ Point2D(2.1, 1.4)
+
+ Notes
+ =====
+
+ When creating a random point, one may simply replace the
+ parameter with a random number. When doing so, however, the
+ random number should be made a Rational or else the point
+ may not test as being in the ellipse:
+
+ >>> from sympy.abc import t
+ >>> from sympy import Rational
+ >>> arb = e1.arbitrary_point(t); arb
+ Point2D(3*cos(t), 2*sin(t))
+ >>> arb.subs(t, .1) in e1
+ False
+ >>> arb.subs(t, Rational(.1)) in e1
+ True
+ >>> arb.subs(t, Rational('.1')) in e1
+ True
+
+ See Also
+ ========
+ sympy.geometry.point.Point
+ arbitrary_point : Returns parameterized point on ellipse
+ """
+ t = _symbol('t', real=True)
+ x, y = self.arbitrary_point(t).args
+ # get a random value in [-1, 1) corresponding to cos(t)
+ # and confirm that it will test as being in the ellipse
+ if seed is not None:
+ rng = random.Random(seed)
+ else:
+ rng = random
+ # simplify this now or else the Float will turn s into a Float
+ r = Rational(rng.random())
+ c = 2*r - 1
+ s = sqrt(1 - c**2)
+ return Point(x.subs(cos(t), c), y.subs(sin(t), s))
+
+ def reflect(self, line):
+ """Override GeometryEntity.reflect since the radius
+ is not a GeometryEntity.
+
+ Examples
+ ========
+
+ >>> from sympy import Circle, Line
+ >>> Circle((0, 1), 1).reflect(Line((0, 0), (1, 1)))
+ Circle(Point2D(1, 0), -1)
+ >>> from sympy import Ellipse, Line, Point
+ >>> Ellipse(Point(3, 4), 1, 3).reflect(Line(Point(0, -4), Point(5, 0)))
+ Traceback (most recent call last):
+ ...
+ NotImplementedError:
+ General Ellipse is not supported but the equation of the reflected
+ Ellipse is given by the zeros of: f(x, y) = (9*x/41 + 40*y/41 +
+ 37/41)**2 + (40*x/123 - 3*y/41 - 364/123)**2 - 1
+
+ Notes
+ =====
+
+ Until the general ellipse (with no axis parallel to the x-axis) is
+ supported a NotImplemented error is raised and the equation whose
+ zeros define the rotated ellipse is given.
+
+ """
+
+ if line.slope in (0, oo):
+ c = self.center
+ c = c.reflect(line)
+ return self.func(c, -self.hradius, self.vradius)
+ else:
+ x, y = [uniquely_named_symbol(
+ name, (self, line), modify=lambda s: '_' + s, real=True)
+ for name in 'xy']
+ expr = self.equation(x, y)
+ p = Point(x, y).reflect(line)
+ result = expr.subs(zip((x, y), p.args
+ ), simultaneous=True)
+ raise NotImplementedError(filldedent(
+ 'General Ellipse is not supported but the equation '
+ 'of the reflected Ellipse is given by the zeros of: ' +
+ "f(%s, %s) = %s" % (str(x), str(y), str(result))))
+
+ def rotate(self, angle=0, pt=None):
+ """Rotate ``angle`` radians counterclockwise about Point ``pt``.
+
+ Note: since the general ellipse is not supported, only rotations that
+ are integer multiples of pi/2 are allowed.
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse, pi
+ >>> Ellipse((1, 0), 2, 1).rotate(pi/2)
+ Ellipse(Point2D(0, 1), 1, 2)
+ >>> Ellipse((1, 0), 2, 1).rotate(pi)
+ Ellipse(Point2D(-1, 0), 2, 1)
+ """
+ if self.hradius == self.vradius:
+ return self.func(self.center.rotate(angle, pt), self.hradius)
+ if (angle/S.Pi).is_integer:
+ return super().rotate(angle, pt)
+ if (2*angle/S.Pi).is_integer:
+ return self.func(self.center.rotate(angle, pt), self.vradius, self.hradius)
+ # XXX see https://github.com/sympy/sympy/issues/2815 for general ellipes
+ raise NotImplementedError('Only rotations of pi/2 are currently supported for Ellipse.')
+
+ def scale(self, x=1, y=1, pt=None):
+ """Override GeometryEntity.scale since it is the major and minor
+ axes which must be scaled and they are not GeometryEntities.
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse
+ >>> Ellipse((0, 0), 2, 1).scale(2, 4)
+ Circle(Point2D(0, 0), 4)
+ >>> Ellipse((0, 0), 2, 1).scale(2)
+ Ellipse(Point2D(0, 0), 4, 1)
+ """
+ c = self.center
+ if pt:
+ pt = Point(pt, dim=2)
+ return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+ h = self.hradius
+ v = self.vradius
+ return self.func(c.scale(x, y), hradius=h*x, vradius=v*y)
+
+ def tangent_lines(self, p):
+ """Tangent lines between `p` and the ellipse.
+
+ If `p` is on the ellipse, returns the tangent line through point `p`.
+ Otherwise, returns the tangent line(s) from `p` to the ellipse, or
+ None if no tangent line is possible (e.g., `p` inside ellipse).
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ tangent_lines : list with 1 or 2 Lines
+
+ Raises
+ ======
+
+ NotImplementedError
+ Can only find tangent lines for a point, `p`, on the ellipse.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, sympy.geometry.line.Line
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> e1 = Ellipse(Point(0, 0), 3, 2)
+ >>> e1.tangent_lines(Point(3, 0))
+ [Line2D(Point2D(3, 0), Point2D(3, -12))]
+
+ """
+ p = Point(p, dim=2)
+ if self.encloses_point(p):
+ return []
+
+ if p in self:
+ delta = self.center - p
+ rise = (self.vradius**2)*delta.x
+ run = -(self.hradius**2)*delta.y
+ p2 = Point(simplify(p.x + run),
+ simplify(p.y + rise))
+ return [Line(p, p2)]
+ else:
+ if len(self.foci) == 2:
+ f1, f2 = self.foci
+ maj = self.hradius
+ test = (2*maj -
+ Point.distance(f1, p) -
+ Point.distance(f2, p))
+ else:
+ test = self.radius - Point.distance(self.center, p)
+ if test.is_number and test.is_positive:
+ return []
+ # else p is outside the ellipse or we can't tell. In case of the
+ # latter, the solutions returned will only be valid if
+ # the point is not inside the ellipse; if it is, nan will result.
+ eq = self.equation(x, y)
+ dydx = idiff(eq, y, x)
+ slope = Line(p, Point(x, y)).slope
+
+ # TODO: Replace solve with solveset, when this line is tested
+ tangent_points = solve([slope - dydx, eq], [x, y])
+
+ # handle horizontal and vertical tangent lines
+ if len(tangent_points) == 1:
+ if tangent_points[0][
+ 0] == p.x or tangent_points[0][1] == p.y:
+ return [Line(p, p + Point(1, 0)), Line(p, p + Point(0, 1))]
+ else:
+ return [Line(p, p + Point(0, 1)), Line(p, tangent_points[0])]
+
+ # others
+ return [Line(p, tangent_points[0]), Line(p, tangent_points[1])]
+
+ @property
+ def vradius(self):
+ """The vertical radius of the ellipse.
+
+ Returns
+ =======
+
+ vradius : number
+
+ See Also
+ ========
+
+ hradius, major, minor
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.vradius
+ 1
+
+ """
+ return self.args[2]
+
+
+ def second_moment_of_area(self, point=None):
+ """Returns the second moment and product moment area of an ellipse.
+
+ Parameters
+ ==========
+
+ point : Point, two-tuple of sympifiable objects, or None(default=None)
+ point is the point about which second moment of area is to be found.
+ If "point=None" it will be calculated about the axis passing through the
+ centroid of the ellipse.
+
+ Returns
+ =======
+
+ I_xx, I_yy, I_xy : number or SymPy expression
+ I_xx, I_yy are second moment of area of an ellise.
+ I_xy is product moment of area of an ellipse.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.second_moment_of_area()
+ (3*pi/4, 27*pi/4, 0)
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/List_of_second_moments_of_area
+
+ """
+
+ I_xx = (S.Pi*(self.hradius)*(self.vradius**3))/4
+ I_yy = (S.Pi*(self.hradius**3)*(self.vradius))/4
+ I_xy = 0
+
+ if point is None:
+ return I_xx, I_yy, I_xy
+
+ # parallel axis theorem
+ I_xx = I_xx + self.area*((point[1] - self.center.y)**2)
+ I_yy = I_yy + self.area*((point[0] - self.center.x)**2)
+ I_xy = I_xy + self.area*(point[0] - self.center.x)*(point[1] - self.center.y)
+
+ return I_xx, I_yy, I_xy
+
+
+ def polar_second_moment_of_area(self):
+ """Returns the polar second moment of area of an Ellipse
+
+ It is a constituent of the second moment of area, linked through
+ the perpendicular axis theorem. While the planar second moment of
+ area describes an object's resistance to deflection (bending) when
+ subjected to a force applied to a plane parallel to the central
+ axis, the polar second moment of area describes an object's
+ resistance to deflection when subjected to a moment applied in a
+ plane perpendicular to the object's central axis (i.e. parallel to
+ the cross-section)
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, Circle, Ellipse
+ >>> c = Circle((5, 5), 4)
+ >>> c.polar_second_moment_of_area()
+ 128*pi
+ >>> a, b = symbols('a, b')
+ >>> e = Ellipse((0, 0), a, b)
+ >>> e.polar_second_moment_of_area()
+ pi*a**3*b/4 + pi*a*b**3/4
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Polar_moment_of_inertia
+
+ """
+ second_moment = self.second_moment_of_area()
+ return second_moment[0] + second_moment[1]
+
+
+ def section_modulus(self, point=None):
+ """Returns a tuple with the section modulus of an ellipse
+
+ Section modulus is a geometric property of an ellipse defined as the
+ ratio of second moment of area to the distance of the extreme end of
+ the ellipse from the centroidal axis.
+
+ Parameters
+ ==========
+
+ point : Point, two-tuple of sympifyable objects, or None(default=None)
+ point is the point at which section modulus is to be found.
+ If "point=None" section modulus will be calculated for the
+ point farthest from the centroidal axis of the ellipse.
+
+ Returns
+ =======
+
+ S_x, S_y: numbers or SymPy expressions
+ S_x is the section modulus with respect to the x-axis
+ S_y is the section modulus with respect to the y-axis
+ A negative sign indicates that the section modulus is
+ determined for a point below the centroidal axis.
+
+ Examples
+ ========
+
+ >>> from sympy import Symbol, Ellipse, Circle, Point2D
+ >>> d = Symbol('d', positive=True)
+ >>> c = Circle((0, 0), d/2)
+ >>> c.section_modulus()
+ (pi*d**3/32, pi*d**3/32)
+ >>> e = Ellipse(Point2D(0, 0), 2, 4)
+ >>> e.section_modulus()
+ (8*pi, 4*pi)
+ >>> e.section_modulus((2, 2))
+ (16*pi, 4*pi)
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Section_modulus
+
+ """
+ x_c, y_c = self.center
+ if point is None:
+ # taking x and y as maximum distances from centroid
+ x_min, y_min, x_max, y_max = self.bounds
+ y = max(y_c - y_min, y_max - y_c)
+ x = max(x_c - x_min, x_max - x_c)
+ else:
+ # taking x and y as distances of the given point from the center
+ point = Point2D(point)
+ y = point.y - y_c
+ x = point.x - x_c
+
+ second_moment = self.second_moment_of_area()
+ S_x = second_moment[0]/y
+ S_y = second_moment[1]/x
+
+ return S_x, S_y
+
+
+class Circle(Ellipse):
+ """A circle in space.
+
+ Constructed simply from a center and a radius, from three
+ non-collinear points, or the equation of a circle.
+
+ Parameters
+ ==========
+
+ center : Point
+ radius : number or SymPy expression
+ points : sequence of three Points
+ equation : equation of a circle
+
+ Attributes
+ ==========
+
+ radius (synonymous with hradius, vradius, major and minor)
+ circumference
+ equation
+
+ Raises
+ ======
+
+ GeometryError
+ When the given equation is not that of a circle.
+ When trying to construct circle from incorrect parameters.
+
+ See Also
+ ========
+
+ Ellipse, sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Circle, Eq
+ >>> from sympy.abc import x, y, a, b
+
+ A circle constructed from a center and radius:
+
+ >>> c1 = Circle(Point(0, 0), 5)
+ >>> c1.hradius, c1.vradius, c1.radius
+ (5, 5, 5)
+
+ A circle constructed from three points:
+
+ >>> c2 = Circle(Point(0, 0), Point(1, 1), Point(1, 0))
+ >>> c2.hradius, c2.vradius, c2.radius, c2.center
+ (sqrt(2)/2, sqrt(2)/2, sqrt(2)/2, Point2D(1/2, 1/2))
+
+ A circle can be constructed from an equation in the form
+ `a*x**2 + by**2 + gx + hy + c = 0`, too:
+
+ >>> Circle(x**2 + y**2 - 25)
+ Circle(Point2D(0, 0), 5)
+
+ If the variables corresponding to x and y are named something
+ else, their name or symbol can be supplied:
+
+ >>> Circle(Eq(a**2 + b**2, 25), x='a', y=b)
+ Circle(Point2D(0, 0), 5)
+ """
+
+ def __new__(cls, *args, **kwargs):
+ evaluate = kwargs.get('evaluate', global_parameters.evaluate)
+ if len(args) == 1 and isinstance(args[0], (Expr, Eq)):
+ x = kwargs.get('x', 'x')
+ y = kwargs.get('y', 'y')
+ equation = args[0].expand()
+ if isinstance(equation, Eq):
+ equation = equation.lhs - equation.rhs
+ x = find(x, equation)
+ y = find(y, equation)
+
+ try:
+ a, b, c, d, e = linear_coeffs(equation, x**2, y**2, x, y)
+ except ValueError:
+ raise GeometryError("The given equation is not that of a circle.")
+
+ if S.Zero in (a, b) or a != b:
+ raise GeometryError("The given equation is not that of a circle.")
+
+ center_x = -c/a/2
+ center_y = -d/b/2
+ r2 = (center_x**2) + (center_y**2) - e/a
+
+ return Circle((center_x, center_y), sqrt(r2), evaluate=evaluate)
+
+ else:
+ c, r = None, None
+ if len(args) == 3:
+ args = [Point(a, dim=2, evaluate=evaluate) for a in args]
+ t = Triangle(*args)
+ if not isinstance(t, Triangle):
+ return t
+ c = t.circumcenter
+ r = t.circumradius
+ elif len(args) == 2:
+ # Assume (center, radius) pair
+ c = Point(args[0], dim=2, evaluate=evaluate)
+ r = args[1]
+ # this will prohibit imaginary radius
+ try:
+ r = Point(r, 0, evaluate=evaluate).x
+ except ValueError:
+ raise GeometryError("Circle with imaginary radius is not permitted")
+
+ if not (c is None or r is None):
+ if r == 0:
+ return c
+ return GeometryEntity.__new__(cls, c, r, **kwargs)
+
+ raise GeometryError("Circle.__new__ received unknown arguments")
+
+ def _eval_evalf(self, prec=15, **options):
+ pt, r = self.args
+ dps = prec_to_dps(prec)
+ pt = pt.evalf(n=dps, **options)
+ r = r.evalf(n=dps, **options)
+ return self.func(pt, r, evaluate=False)
+
+ @property
+ def circumference(self):
+ """The circumference of the circle.
+
+ Returns
+ =======
+
+ circumference : number or SymPy expression
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Circle
+ >>> c1 = Circle(Point(3, 4), 6)
+ >>> c1.circumference
+ 12*pi
+
+ """
+ return 2 * S.Pi * self.radius
+
+ def equation(self, x='x', y='y'):
+ """The equation of the circle.
+
+ Parameters
+ ==========
+
+ x : str or Symbol, optional
+ Default value is 'x'.
+ y : str or Symbol, optional
+ Default value is 'y'.
+
+ Returns
+ =======
+
+ equation : SymPy expression
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Circle
+ >>> c1 = Circle(Point(0, 0), 5)
+ >>> c1.equation()
+ x**2 + y**2 - 25
+
+ """
+ x = _symbol(x, real=True)
+ y = _symbol(y, real=True)
+ t1 = (x - self.center.x)**2
+ t2 = (y - self.center.y)**2
+ return t1 + t2 - self.major**2
+
+ def intersection(self, o):
+ """The intersection of this circle with another geometrical entity.
+
+ Parameters
+ ==========
+
+ o : GeometryEntity
+
+ Returns
+ =======
+
+ intersection : list of GeometryEntities
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Circle, Line, Ray
+ >>> p1, p2, p3 = Point(0, 0), Point(5, 5), Point(6, 0)
+ >>> p4 = Point(5, 0)
+ >>> c1 = Circle(p1, 5)
+ >>> c1.intersection(p2)
+ []
+ >>> c1.intersection(p4)
+ [Point2D(5, 0)]
+ >>> c1.intersection(Ray(p1, p2))
+ [Point2D(5*sqrt(2)/2, 5*sqrt(2)/2)]
+ >>> c1.intersection(Line(p2, p3))
+ []
+
+ """
+ return Ellipse.intersection(self, o)
+
+ @property
+ def radius(self):
+ """The radius of the circle.
+
+ Returns
+ =======
+
+ radius : number or SymPy expression
+
+ See Also
+ ========
+
+ Ellipse.major, Ellipse.minor, Ellipse.hradius, Ellipse.vradius
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Circle
+ >>> c1 = Circle(Point(3, 4), 6)
+ >>> c1.radius
+ 6
+
+ """
+ return self.args[1]
+
+ def reflect(self, line):
+ """Override GeometryEntity.reflect since the radius
+ is not a GeometryEntity.
+
+ Examples
+ ========
+
+ >>> from sympy import Circle, Line
+ >>> Circle((0, 1), 1).reflect(Line((0, 0), (1, 1)))
+ Circle(Point2D(1, 0), -1)
+ """
+ c = self.center
+ c = c.reflect(line)
+ return self.func(c, -self.radius)
+
+ def scale(self, x=1, y=1, pt=None):
+ """Override GeometryEntity.scale since the radius
+ is not a GeometryEntity.
+
+ Examples
+ ========
+
+ >>> from sympy import Circle
+ >>> Circle((0, 0), 1).scale(2, 2)
+ Circle(Point2D(0, 0), 2)
+ >>> Circle((0, 0), 1).scale(2, 4)
+ Ellipse(Point2D(0, 0), 2, 4)
+ """
+ c = self.center
+ if pt:
+ pt = Point(pt, dim=2)
+ return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+ c = c.scale(x, y)
+ x, y = [abs(i) for i in (x, y)]
+ if x == y:
+ return self.func(c, x*self.radius)
+ h = v = self.radius
+ return Ellipse(c, hradius=h*x, vradius=v*y)
+
+ @property
+ def vradius(self):
+ """
+ This Ellipse property is an alias for the Circle's radius.
+
+ Whereas hradius, major and minor can use Ellipse's conventions,
+ the vradius does not exist for a circle. It is always a positive
+ value in order that the Circle, like Polygons, will have an
+ area that can be positive or negative as determined by the sign
+ of the hradius.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Circle
+ >>> c1 = Circle(Point(3, 4), 6)
+ >>> c1.vradius
+ 6
+ """
+ return abs(self.radius)
+
+
+from .polygon import Polygon, Triangle
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/exceptions.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..41d97af718de2cebad3accefcd60e43ccf74a3f6
--- /dev/null
+++ b/llmeval-env/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/llmeval-env/lib/python3.10/site-packages/sympy/geometry/line.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/line.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c60a14998c091640f513e061ea971c47533280d
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/line.py
@@ -0,0 +1,2803 @@
+"""Line-like geometrical entities.
+
+Contains
+========
+LinearEntity
+Line
+Ray
+Segment
+LinearEntity2D
+Line2D
+Ray2D
+Segment2D
+LinearEntity3D
+Line3D
+Ray3D
+Segment3D
+
+"""
+
+from sympy.core.containers import Tuple
+from sympy.core.evalf import N
+from sympy.core.expr import Expr
+from sympy.core.numbers import Rational, oo, Float
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import _symbol, Dummy, uniquely_named_symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (_pi_coeff, acos, tan, atan2)
+from .entity import GeometryEntity, GeometrySet
+from .exceptions import GeometryError
+from .point import Point, Point3D
+from .util import find, intersection
+from sympy.logic.boolalg import And
+from sympy.matrices import Matrix
+from sympy.sets.sets import Intersection
+from sympy.simplify.simplify import simplify
+from sympy.solvers.solvers import solve
+from sympy.solvers.solveset import linear_coeffs
+from sympy.utilities.misc import Undecidable, filldedent
+
+
+import random
+
+
+t, u = [Dummy('line_dummy') for i in range(2)]
+
+
+class LinearEntity(GeometrySet):
+ """A base class for all linear entities (Line, Ray and Segment)
+ in n-dimensional Euclidean space.
+
+ Attributes
+ ==========
+
+ ambient_dimension
+ direction
+ length
+ p1
+ p2
+ points
+
+ Notes
+ =====
+
+ This is an abstract class and is not meant to be instantiated.
+
+ See Also
+ ========
+
+ sympy.geometry.entity.GeometryEntity
+
+ """
+ def __new__(cls, p1, p2=None, **kwargs):
+ p1, p2 = Point._normalize_dimension(p1, p2)
+ if p1 == p2:
+ # sometimes we return a single point if we are not given two unique
+ # points. This is done in the specific subclass
+ raise ValueError(
+ "%s.__new__ requires two unique Points." % cls.__name__)
+ if len(p1) != len(p2):
+ raise ValueError(
+ "%s.__new__ requires two Points of equal dimension." % cls.__name__)
+
+ return GeometryEntity.__new__(cls, p1, p2, **kwargs)
+
+ def __contains__(self, other):
+ """Return a definitive answer or else raise an error if it cannot
+ be determined that other is on the boundaries of self."""
+ result = self.contains(other)
+
+ if result is not None:
+ return result
+ else:
+ raise Undecidable(
+ "Cannot decide whether '%s' contains '%s'" % (self, other))
+
+ def _span_test(self, other):
+ """Test whether the point `other` lies in the positive span of `self`.
+ A point x is 'in front' of a point y if x.dot(y) >= 0. Return
+ -1 if `other` is behind `self.p1`, 0 if `other` is `self.p1` and
+ and 1 if `other` is in front of `self.p1`."""
+ if self.p1 == other:
+ return 0
+
+ rel_pos = other - self.p1
+ d = self.direction
+ if d.dot(rel_pos) > 0:
+ return 1
+ return -1
+
+ @property
+ def ambient_dimension(self):
+ """A property method that returns the dimension of LinearEntity
+ object.
+
+ Parameters
+ ==========
+
+ p1 : LinearEntity
+
+ Returns
+ =======
+
+ dimension : integer
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(1, 1)
+ >>> l1 = Line(p1, p2)
+ >>> l1.ambient_dimension
+ 2
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0, 0), Point(1, 1, 1)
+ >>> l1 = Line(p1, p2)
+ >>> l1.ambient_dimension
+ 3
+
+ """
+ return len(self.p1)
+
+ def angle_between(l1, l2):
+ """Return the non-reflex angle formed by rays emanating from
+ the origin with directions the same as the direction vectors
+ of the linear entities.
+
+ Parameters
+ ==========
+
+ l1 : LinearEntity
+ l2 : LinearEntity
+
+ Returns
+ =======
+
+ angle : angle in radians
+
+ Notes
+ =====
+
+ From the dot product of vectors v1 and v2 it is known that:
+
+ ``dot(v1, v2) = |v1|*|v2|*cos(A)``
+
+ where A is the angle formed between the two vectors. We can
+ get the directional vectors of the two lines and readily
+ find the angle between the two using the above formula.
+
+ See Also
+ ========
+
+ is_perpendicular, Ray2D.closing_angle
+
+ Examples
+ ========
+
+ >>> from sympy import Line
+ >>> e = Line((0, 0), (1, 0))
+ >>> ne = Line((0, 0), (1, 1))
+ >>> sw = Line((1, 1), (0, 0))
+ >>> ne.angle_between(e)
+ pi/4
+ >>> sw.angle_between(e)
+ 3*pi/4
+
+ To obtain the non-obtuse angle at the intersection of lines, use
+ the ``smallest_angle_between`` method:
+
+ >>> sw.smallest_angle_between(e)
+ pi/4
+
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(-1, 2, 0)
+ >>> l1, l2 = Line3D(p1, p2), Line3D(p2, p3)
+ >>> l1.angle_between(l2)
+ acos(-sqrt(2)/3)
+ >>> l1.smallest_angle_between(l2)
+ acos(sqrt(2)/3)
+ """
+ if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+ raise TypeError('Must pass only LinearEntity objects')
+
+ v1, v2 = l1.direction, l2.direction
+ return acos(v1.dot(v2)/(abs(v1)*abs(v2)))
+
+ def smallest_angle_between(l1, l2):
+ """Return the smallest angle formed at the intersection of the
+ lines containing the linear entities.
+
+ Parameters
+ ==========
+
+ l1 : LinearEntity
+ l2 : LinearEntity
+
+ Returns
+ =======
+
+ angle : angle in radians
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2, p3 = Point(0, 0), Point(0, 4), Point(2, -2)
+ >>> l1, l2 = Line(p1, p2), Line(p1, p3)
+ >>> l1.smallest_angle_between(l2)
+ pi/4
+
+ See Also
+ ========
+
+ angle_between, is_perpendicular, Ray2D.closing_angle
+ """
+ if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+ raise TypeError('Must pass only LinearEntity objects')
+
+ v1, v2 = l1.direction, l2.direction
+ return acos(abs(v1.dot(v2))/(abs(v1)*abs(v2)))
+
+ def arbitrary_point(self, parameter='t'):
+ """A parameterized point on the Line.
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ The name of the parameter which will be used for the parametric
+ point. The default value is 't'. When this parameter is 0, the
+ first point used to define the line will be returned, and when
+ it is 1 the second point will be returned.
+
+ Returns
+ =======
+
+ point : Point
+
+ Raises
+ ======
+
+ ValueError
+ When ``parameter`` already appears in the Line's definition.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(1, 0), Point(5, 3)
+ >>> l1 = Line(p1, p2)
+ >>> l1.arbitrary_point()
+ Point2D(4*t + 1, 3*t)
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2 = Point3D(1, 0, 0), Point3D(5, 3, 1)
+ >>> l1 = Line3D(p1, p2)
+ >>> l1.arbitrary_point()
+ Point3D(4*t + 1, 3*t, t)
+
+ """
+ t = _symbol(parameter, real=True)
+ if t.name in (f.name for f in self.free_symbols):
+ raise ValueError(filldedent('''
+ Symbol %s already appears in object
+ and cannot be used as a parameter.
+ ''' % t.name))
+ # multiply on the right so the variable gets
+ # combined with the coordinates of the point
+ return self.p1 + (self.p2 - self.p1)*t
+
+ @staticmethod
+ def are_concurrent(*lines):
+ """Is a sequence of linear entities concurrent?
+
+ Two or more linear entities are concurrent if they all
+ intersect at a single point.
+
+ Parameters
+ ==========
+
+ lines
+ A sequence of linear entities.
+
+ Returns
+ =======
+
+ True : if the set of linear entities intersect in one point
+ False : otherwise.
+
+ See Also
+ ========
+
+ sympy.geometry.util.intersection
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(3, 5)
+ >>> p3, p4 = Point(-2, -2), Point(0, 2)
+ >>> l1, l2, l3 = Line(p1, p2), Line(p1, p3), Line(p1, p4)
+ >>> Line.are_concurrent(l1, l2, l3)
+ True
+ >>> l4 = Line(p2, p3)
+ >>> Line.are_concurrent(l2, l3, l4)
+ False
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(3, 5, 2)
+ >>> p3, p4 = Point3D(-2, -2, -2), Point3D(0, 2, 1)
+ >>> l1, l2, l3 = Line3D(p1, p2), Line3D(p1, p3), Line3D(p1, p4)
+ >>> Line3D.are_concurrent(l1, l2, l3)
+ True
+ >>> l4 = Line3D(p2, p3)
+ >>> Line3D.are_concurrent(l2, l3, l4)
+ False
+
+ """
+ common_points = Intersection(*lines)
+ if common_points.is_FiniteSet and len(common_points) == 1:
+ return True
+ return False
+
+ def contains(self, other):
+ """Subclasses should implement this method and should return
+ True if other is on the boundaries of self;
+ False if not on the boundaries of self;
+ None if a determination cannot be made."""
+ raise NotImplementedError()
+
+ @property
+ def direction(self):
+ """The direction vector of the LinearEntity.
+
+ Returns
+ =======
+
+ p : a Point; the ray from the origin to this point is the
+ direction of `self`
+
+ Examples
+ ========
+
+ >>> from sympy import Line
+ >>> a, b = (1, 1), (1, 3)
+ >>> Line(a, b).direction
+ Point2D(0, 2)
+ >>> Line(b, a).direction
+ Point2D(0, -2)
+
+ This can be reported so the distance from the origin is 1:
+
+ >>> Line(b, a).direction.unit
+ Point2D(0, -1)
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.unit
+
+ """
+ return self.p2 - self.p1
+
+ def intersection(self, other):
+ """The intersection with another geometrical entity.
+
+ Parameters
+ ==========
+
+ o : Point or LinearEntity
+
+ Returns
+ =======
+
+ intersection : list of geometrical entities
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line, Segment
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(7, 7)
+ >>> l1 = Line(p1, p2)
+ >>> l1.intersection(p3)
+ [Point2D(7, 7)]
+ >>> p4, p5 = Point(5, 0), Point(0, 3)
+ >>> l2 = Line(p4, p5)
+ >>> l1.intersection(l2)
+ [Point2D(15/8, 15/8)]
+ >>> p6, p7 = Point(0, 5), Point(2, 6)
+ >>> s1 = Segment(p6, p7)
+ >>> l1.intersection(s1)
+ []
+ >>> from sympy import Point3D, Line3D, Segment3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(7, 7, 7)
+ >>> l1 = Line3D(p1, p2)
+ >>> l1.intersection(p3)
+ [Point3D(7, 7, 7)]
+ >>> l1 = Line3D(Point3D(4,19,12), Point3D(5,25,17))
+ >>> l2 = Line3D(Point3D(-3, -15, -19), direction_ratio=[2,8,8])
+ >>> l1.intersection(l2)
+ [Point3D(1, 1, -3)]
+ >>> p6, p7 = Point3D(0, 5, 2), Point3D(2, 6, 3)
+ >>> s1 = Segment3D(p6, p7)
+ >>> l1.intersection(s1)
+ []
+
+ """
+ def intersect_parallel_rays(ray1, ray2):
+ if ray1.direction.dot(ray2.direction) > 0:
+ # rays point in the same direction
+ # so return the one that is "in front"
+ return [ray2] if ray1._span_test(ray2.p1) >= 0 else [ray1]
+ else:
+ # rays point in opposite directions
+ st = ray1._span_test(ray2.p1)
+ if st < 0:
+ return []
+ elif st == 0:
+ return [ray2.p1]
+ return [Segment(ray1.p1, ray2.p1)]
+
+ def intersect_parallel_ray_and_segment(ray, seg):
+ st1, st2 = ray._span_test(seg.p1), ray._span_test(seg.p2)
+ if st1 < 0 and st2 < 0:
+ return []
+ elif st1 >= 0 and st2 >= 0:
+ return [seg]
+ elif st1 >= 0: # st2 < 0:
+ return [Segment(ray.p1, seg.p1)]
+ else: # st1 < 0 and st2 >= 0:
+ return [Segment(ray.p1, seg.p2)]
+
+ def intersect_parallel_segments(seg1, seg2):
+ if seg1.contains(seg2):
+ return [seg2]
+ if seg2.contains(seg1):
+ return [seg1]
+
+ # direct the segments so they're oriented the same way
+ if seg1.direction.dot(seg2.direction) < 0:
+ seg2 = Segment(seg2.p2, seg2.p1)
+ # order the segments so seg1 is "behind" seg2
+ if seg1._span_test(seg2.p1) < 0:
+ seg1, seg2 = seg2, seg1
+ if seg2._span_test(seg1.p2) < 0:
+ return []
+ return [Segment(seg2.p1, seg1.p2)]
+
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if other.is_Point:
+ if self.contains(other):
+ return [other]
+ else:
+ return []
+ elif isinstance(other, LinearEntity):
+ # break into cases based on whether
+ # the lines are parallel, non-parallel intersecting, or skew
+ pts = Point._normalize_dimension(self.p1, self.p2, other.p1, other.p2)
+ rank = Point.affine_rank(*pts)
+
+ if rank == 1:
+ # we're collinear
+ if isinstance(self, Line):
+ return [other]
+ if isinstance(other, Line):
+ return [self]
+
+ if isinstance(self, Ray) and isinstance(other, Ray):
+ return intersect_parallel_rays(self, other)
+ if isinstance(self, Ray) and isinstance(other, Segment):
+ return intersect_parallel_ray_and_segment(self, other)
+ if isinstance(self, Segment) and isinstance(other, Ray):
+ return intersect_parallel_ray_and_segment(other, self)
+ if isinstance(self, Segment) and isinstance(other, Segment):
+ return intersect_parallel_segments(self, other)
+ elif rank == 2:
+ # we're in the same plane
+ l1 = Line(*pts[:2])
+ l2 = Line(*pts[2:])
+
+ # check to see if we're parallel. If we are, we can't
+ # be intersecting, since the collinear case was already
+ # handled
+ if l1.direction.is_scalar_multiple(l2.direction):
+ return []
+
+ # find the intersection as if everything were lines
+ # by solving the equation t*d + p1 == s*d' + p1'
+ m = Matrix([l1.direction, -l2.direction]).transpose()
+ v = Matrix([l2.p1 - l1.p1]).transpose()
+
+ # we cannot use m.solve(v) because that only works for square matrices
+ m_rref, pivots = m.col_insert(2, v).rref(simplify=True)
+ # rank == 2 ensures we have 2 pivots, but let's check anyway
+ if len(pivots) != 2:
+ raise GeometryError("Failed when solving Mx=b when M={} and b={}".format(m, v))
+ coeff = m_rref[0, 2]
+ line_intersection = l1.direction*coeff + self.p1
+
+ # if both are lines, skip a containment check
+ if isinstance(self, Line) and isinstance(other, Line):
+ return [line_intersection]
+
+ if ((isinstance(self, Line) or
+ self.contains(line_intersection)) and
+ other.contains(line_intersection)):
+ return [line_intersection]
+ if not self.atoms(Float) and not other.atoms(Float):
+ # if it can fail when there are no Floats then
+ # maybe the following parametric check should be
+ # done
+ return []
+ # floats may fail exact containment so check that the
+ # arbitrary points, when equal, both give a
+ # non-negative parameter when the arbitrary point
+ # coordinates are equated
+ tu = solve(self.arbitrary_point(t) - other.arbitrary_point(u),
+ t, u, dict=True)[0]
+ def ok(p, l):
+ if isinstance(l, Line):
+ # p > -oo
+ return True
+ if isinstance(l, Ray):
+ # p >= 0
+ return p.is_nonnegative
+ if isinstance(l, Segment):
+ # 0 <= p <= 1
+ return p.is_nonnegative and (1 - p).is_nonnegative
+ raise ValueError("unexpected line type")
+ if ok(tu[t], self) and ok(tu[u], other):
+ return [line_intersection]
+ return []
+ else:
+ # we're skew
+ return []
+
+ return other.intersection(self)
+
+ def is_parallel(l1, l2):
+ """Are two linear entities parallel?
+
+ Parameters
+ ==========
+
+ l1 : LinearEntity
+ l2 : LinearEntity
+
+ Returns
+ =======
+
+ True : if l1 and l2 are parallel,
+ False : otherwise.
+
+ See Also
+ ========
+
+ coefficients
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(1, 1)
+ >>> p3, p4 = Point(3, 4), Point(6, 7)
+ >>> l1, l2 = Line(p1, p2), Line(p3, p4)
+ >>> Line.is_parallel(l1, l2)
+ True
+ >>> p5 = Point(6, 6)
+ >>> l3 = Line(p3, p5)
+ >>> Line.is_parallel(l1, l3)
+ False
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(3, 4, 5)
+ >>> p3, p4 = Point3D(2, 1, 1), Point3D(8, 9, 11)
+ >>> l1, l2 = Line3D(p1, p2), Line3D(p3, p4)
+ >>> Line3D.is_parallel(l1, l2)
+ True
+ >>> p5 = Point3D(6, 6, 6)
+ >>> l3 = Line3D(p3, p5)
+ >>> Line3D.is_parallel(l1, l3)
+ False
+
+ """
+ if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+ raise TypeError('Must pass only LinearEntity objects')
+
+ return l1.direction.is_scalar_multiple(l2.direction)
+
+ def is_perpendicular(l1, l2):
+ """Are two linear entities perpendicular?
+
+ Parameters
+ ==========
+
+ l1 : LinearEntity
+ l2 : LinearEntity
+
+ Returns
+ =======
+
+ True : if l1 and l2 are perpendicular,
+ False : otherwise.
+
+ See Also
+ ========
+
+ coefficients
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(-1, 1)
+ >>> l1, l2 = Line(p1, p2), Line(p1, p3)
+ >>> l1.is_perpendicular(l2)
+ True
+ >>> p4 = Point(5, 3)
+ >>> l3 = Line(p1, p4)
+ >>> l1.is_perpendicular(l3)
+ False
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(-1, 2, 0)
+ >>> l1, l2 = Line3D(p1, p2), Line3D(p2, p3)
+ >>> l1.is_perpendicular(l2)
+ False
+ >>> p4 = Point3D(5, 3, 7)
+ >>> l3 = Line3D(p1, p4)
+ >>> l1.is_perpendicular(l3)
+ False
+
+ """
+ if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+ raise TypeError('Must pass only LinearEntity objects')
+
+ return S.Zero.equals(l1.direction.dot(l2.direction))
+
+ def is_similar(self, other):
+ """
+ Return True if self and other are contained in the same line.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2, p3 = Point(0, 1), Point(3, 4), Point(2, 3)
+ >>> l1 = Line(p1, p2)
+ >>> l2 = Line(p1, p3)
+ >>> l1.is_similar(l2)
+ True
+ """
+ l = Line(self.p1, self.p2)
+ return l.contains(other)
+
+ @property
+ def length(self):
+ """
+ The length of the line.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(3, 5)
+ >>> l1 = Line(p1, p2)
+ >>> l1.length
+ oo
+ """
+ return S.Infinity
+
+ @property
+ def p1(self):
+ """The first defining point of a linear entity.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(5, 3)
+ >>> l = Line(p1, p2)
+ >>> l.p1
+ Point2D(0, 0)
+
+ """
+ return self.args[0]
+
+ @property
+ def p2(self):
+ """The second defining point of a linear entity.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(5, 3)
+ >>> l = Line(p1, p2)
+ >>> l.p2
+ Point2D(5, 3)
+
+ """
+ return self.args[1]
+
+ def parallel_line(self, p):
+ """Create a new Line parallel to this linear entity which passes
+ through the point `p`.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ line : Line
+
+ See Also
+ ========
+
+ is_parallel
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2, p3 = Point(0, 0), Point(2, 3), Point(-2, 2)
+ >>> l1 = Line(p1, p2)
+ >>> l2 = l1.parallel_line(p3)
+ >>> p3 in l2
+ True
+ >>> l1.is_parallel(l2)
+ True
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(2, 3, 4), Point3D(-2, 2, 0)
+ >>> l1 = Line3D(p1, p2)
+ >>> l2 = l1.parallel_line(p3)
+ >>> p3 in l2
+ True
+ >>> l1.is_parallel(l2)
+ True
+
+ """
+ p = Point(p, dim=self.ambient_dimension)
+ return Line(p, p + self.direction)
+
+ def perpendicular_line(self, p):
+ """Create a new Line perpendicular to this linear entity which passes
+ through the point `p`.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ line : Line
+
+ See Also
+ ========
+
+ sympy.geometry.line.LinearEntity.is_perpendicular, perpendicular_segment
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(2, 3, 4), Point3D(-2, 2, 0)
+ >>> L = Line3D(p1, p2)
+ >>> P = L.perpendicular_line(p3); P
+ Line3D(Point3D(-2, 2, 0), Point3D(4/29, 6/29, 8/29))
+ >>> L.is_perpendicular(P)
+ True
+
+ In 3D the, the first point used to define the line is the point
+ through which the perpendicular was required to pass; the
+ second point is (arbitrarily) contained in the given line:
+
+ >>> P.p2 in L
+ True
+ """
+ p = Point(p, dim=self.ambient_dimension)
+ if p in self:
+ p = p + self.direction.orthogonal_direction
+ return Line(p, self.projection(p))
+
+ def perpendicular_segment(self, p):
+ """Create a perpendicular line segment from `p` to this line.
+
+ The endpoints of the segment are ``p`` and the closest point in
+ the line containing self. (If self is not a line, the point might
+ not be in self.)
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ segment : Segment
+
+ Notes
+ =====
+
+ Returns `p` itself if `p` is on this linear entity.
+
+ See Also
+ ========
+
+ perpendicular_line
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, 2)
+ >>> l1 = Line(p1, p2)
+ >>> s1 = l1.perpendicular_segment(p3)
+ >>> l1.is_perpendicular(s1)
+ True
+ >>> p3 in s1
+ True
+ >>> l1.perpendicular_segment(Point(4, 0))
+ Segment2D(Point2D(4, 0), Point2D(2, 2))
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, 2, 0)
+ >>> l1 = Line3D(p1, p2)
+ >>> s1 = l1.perpendicular_segment(p3)
+ >>> l1.is_perpendicular(s1)
+ True
+ >>> p3 in s1
+ True
+ >>> l1.perpendicular_segment(Point3D(4, 0, 0))
+ Segment3D(Point3D(4, 0, 0), Point3D(4/3, 4/3, 4/3))
+
+ """
+ p = Point(p, dim=self.ambient_dimension)
+ if p in self:
+ return p
+ l = self.perpendicular_line(p)
+ # The intersection should be unique, so unpack the singleton
+ p2, = Intersection(Line(self.p1, self.p2), l)
+
+ return Segment(p, p2)
+
+ @property
+ def points(self):
+ """The two points used to define this linear entity.
+
+ Returns
+ =======
+
+ points : tuple of Points
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(5, 11)
+ >>> l1 = Line(p1, p2)
+ >>> l1.points
+ (Point2D(0, 0), Point2D(5, 11))
+
+ """
+ return (self.p1, self.p2)
+
+ def projection(self, other):
+ """Project a point, line, ray, or segment onto this linear entity.
+
+ Parameters
+ ==========
+
+ other : Point or LinearEntity (Line, Ray, Segment)
+
+ Returns
+ =======
+
+ projection : Point or LinearEntity (Line, Ray, Segment)
+ The return type matches the type of the parameter ``other``.
+
+ Raises
+ ======
+
+ GeometryError
+ When method is unable to perform projection.
+
+ Notes
+ =====
+
+ A projection involves taking the two points that define
+ the linear entity and projecting those points onto a
+ Line and then reforming the linear entity using these
+ projections.
+ A point P is projected onto a line L by finding the point
+ on L that is closest to P. This point is the intersection
+ of L and the line perpendicular to L that passes through P.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, perpendicular_line
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line, Segment, Rational
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(Rational(1, 2), 0)
+ >>> l1 = Line(p1, p2)
+ >>> l1.projection(p3)
+ Point2D(1/4, 1/4)
+ >>> p4, p5 = Point(10, 0), Point(12, 1)
+ >>> s1 = Segment(p4, p5)
+ >>> l1.projection(s1)
+ Segment2D(Point2D(5, 5), Point2D(13/2, 13/2))
+ >>> p1, p2, p3 = Point(0, 0, 1), Point(1, 1, 2), Point(2, 0, 1)
+ >>> l1 = Line(p1, p2)
+ >>> l1.projection(p3)
+ Point3D(2/3, 2/3, 5/3)
+ >>> p4, p5 = Point(10, 0, 1), Point(12, 1, 3)
+ >>> s1 = Segment(p4, p5)
+ >>> l1.projection(s1)
+ Segment3D(Point3D(10/3, 10/3, 13/3), Point3D(5, 5, 6))
+
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+
+ def proj_point(p):
+ return Point.project(p - self.p1, self.direction) + self.p1
+
+ if isinstance(other, Point):
+ return proj_point(other)
+ elif isinstance(other, LinearEntity):
+ p1, p2 = proj_point(other.p1), proj_point(other.p2)
+ # test to see if we're degenerate
+ if p1 == p2:
+ return p1
+ projected = other.__class__(p1, p2)
+ projected = Intersection(self, projected)
+ if projected.is_empty:
+ return projected
+ # if we happen to have intersected in only a point, return that
+ if projected.is_FiniteSet and len(projected) == 1:
+ # projected is a set of size 1, so unpack it in `a`
+ a, = projected
+ return a
+ # order args so projection is in the same direction as self
+ if self.direction.dot(projected.direction) < 0:
+ p1, p2 = projected.args
+ projected = projected.func(p2, p1)
+ return projected
+
+ raise GeometryError(
+ "Do not know how to project %s onto %s" % (other, self))
+
+ def random_point(self, seed=None):
+ """A random point on a LinearEntity.
+
+ Returns
+ =======
+
+ point : Point
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line, Ray, Segment
+ >>> p1, p2 = Point(0, 0), Point(5, 3)
+ >>> line = Line(p1, p2)
+ >>> r = line.random_point(seed=42) # seed value is optional
+ >>> r.n(3)
+ Point2D(-0.72, -0.432)
+ >>> r in line
+ True
+ >>> Ray(p1, p2).random_point(seed=42).n(3)
+ Point2D(0.72, 0.432)
+ >>> Segment(p1, p2).random_point(seed=42).n(3)
+ Point2D(3.2, 1.92)
+
+ """
+ if seed is not None:
+ rng = random.Random(seed)
+ else:
+ rng = random
+ pt = self.arbitrary_point(t)
+ if isinstance(self, Ray):
+ v = abs(rng.gauss(0, 1))
+ elif isinstance(self, Segment):
+ v = rng.random()
+ elif isinstance(self, Line):
+ v = rng.gauss(0, 1)
+ else:
+ raise NotImplementedError('unhandled line type')
+ return pt.subs(t, Rational(v))
+
+ def bisectors(self, other):
+ """Returns the perpendicular lines which pass through the intersections
+ of self and other that are in the same plane.
+
+ Parameters
+ ==========
+
+ line : Line3D
+
+ Returns
+ =======
+
+ list: two Line instances
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D
+ >>> r1 = Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))
+ >>> r2 = Line3D(Point3D(0, 0, 0), Point3D(0, 1, 0))
+ >>> r1.bisectors(r2)
+ [Line3D(Point3D(0, 0, 0), Point3D(1, 1, 0)), Line3D(Point3D(0, 0, 0), Point3D(1, -1, 0))]
+
+ """
+ if not isinstance(other, LinearEntity):
+ raise GeometryError("Expecting LinearEntity, not %s" % other)
+
+ l1, l2 = self, other
+
+ # make sure dimensions match or else a warning will rise from
+ # intersection calculation
+ if l1.p1.ambient_dimension != l2.p1.ambient_dimension:
+ if isinstance(l1, Line2D):
+ l1, l2 = l2, l1
+ _, p1 = Point._normalize_dimension(l1.p1, l2.p1, on_morph='ignore')
+ _, p2 = Point._normalize_dimension(l1.p2, l2.p2, on_morph='ignore')
+ l2 = Line(p1, p2)
+
+ point = intersection(l1, l2)
+
+ # Three cases: Lines may intersect in a point, may be equal or may not intersect.
+ if not point:
+ raise GeometryError("The lines do not intersect")
+ else:
+ pt = point[0]
+ if isinstance(pt, Line):
+ # Intersection is a line because both lines are coincident
+ return [self]
+
+
+ d1 = l1.direction.unit
+ d2 = l2.direction.unit
+
+ bis1 = Line(pt, pt + d1 + d2)
+ bis2 = Line(pt, pt + d1 - d2)
+
+ return [bis1, bis2]
+
+
+class Line(LinearEntity):
+ """An infinite line in space.
+
+ A 2D line is declared with two distinct points, point and slope, or
+ an equation. A 3D line may be defined with a point and a direction ratio.
+
+ Parameters
+ ==========
+
+ p1 : Point
+ p2 : Point
+ slope : SymPy expression
+ direction_ratio : list
+ equation : equation of a line
+
+ Notes
+ =====
+
+ `Line` will automatically subclass to `Line2D` or `Line3D` based
+ on the dimension of `p1`. The `slope` argument is only relevant
+ for `Line2D` and the `direction_ratio` argument is only relevant
+ for `Line3D`.
+
+ The order of the points will define the direction of the line
+ which is used when calculating the angle between lines.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+ sympy.geometry.line.Line2D
+ sympy.geometry.line.Line3D
+
+ Examples
+ ========
+
+ >>> from sympy import Line, Segment, Point, Eq
+ >>> from sympy.abc import x, y, a, b
+
+ >>> L = Line(Point(2,3), Point(3,5))
+ >>> L
+ Line2D(Point2D(2, 3), Point2D(3, 5))
+ >>> L.points
+ (Point2D(2, 3), Point2D(3, 5))
+ >>> L.equation()
+ -2*x + y + 1
+ >>> L.coefficients
+ (-2, 1, 1)
+
+ Instantiate with keyword ``slope``:
+
+ >>> Line(Point(0, 0), slope=0)
+ Line2D(Point2D(0, 0), Point2D(1, 0))
+
+ Instantiate with another linear object
+
+ >>> s = Segment((0, 0), (0, 1))
+ >>> Line(s).equation()
+ x
+
+ The line corresponding to an equation in the for `ax + by + c = 0`,
+ can be entered:
+
+ >>> Line(3*x + y + 18)
+ Line2D(Point2D(0, -18), Point2D(1, -21))
+
+ If `x` or `y` has a different name, then they can be specified, too,
+ as a string (to match the name) or symbol:
+
+ >>> Line(Eq(3*a + b, -18), x='a', y=b)
+ Line2D(Point2D(0, -18), Point2D(1, -21))
+ """
+ def __new__(cls, *args, **kwargs):
+ if len(args) == 1 and isinstance(args[0], (Expr, Eq)):
+ missing = uniquely_named_symbol('?', args)
+ if not kwargs:
+ x = 'x'
+ y = 'y'
+ else:
+ x = kwargs.pop('x', missing)
+ y = kwargs.pop('y', missing)
+ if kwargs:
+ raise ValueError('expecting only x and y as keywords')
+
+ equation = args[0]
+ if isinstance(equation, Eq):
+ equation = equation.lhs - equation.rhs
+
+ def find_or_missing(x):
+ try:
+ return find(x, equation)
+ except ValueError:
+ return missing
+ x = find_or_missing(x)
+ y = find_or_missing(y)
+
+ a, b, c = linear_coeffs(equation, x, y)
+
+ if b:
+ return Line((0, -c/b), slope=-a/b)
+ if a:
+ return Line((-c/a, 0), slope=oo)
+
+ raise ValueError('not found in equation: %s' % (set('xy') - {x, y}))
+
+ else:
+ if len(args) > 0:
+ p1 = args[0]
+ if len(args) > 1:
+ p2 = args[1]
+ else:
+ p2 = None
+
+ if isinstance(p1, LinearEntity):
+ if p2:
+ raise ValueError('If p1 is a LinearEntity, p2 must be None.')
+ dim = len(p1.p1)
+ else:
+ p1 = Point(p1)
+ dim = len(p1)
+ if p2 is not None or isinstance(p2, Point) and p2.ambient_dimension != dim:
+ p2 = Point(p2)
+
+ if dim == 2:
+ return Line2D(p1, p2, **kwargs)
+ elif dim == 3:
+ return Line3D(p1, p2, **kwargs)
+ return LinearEntity.__new__(cls, p1, p2, **kwargs)
+
+ def contains(self, other):
+ """
+ Return True if `other` is on this Line, or False otherwise.
+
+ Examples
+ ========
+
+ >>> from sympy import Line,Point
+ >>> p1, p2 = Point(0, 1), Point(3, 4)
+ >>> l = Line(p1, p2)
+ >>> l.contains(p1)
+ True
+ >>> l.contains((0, 1))
+ True
+ >>> l.contains((0, 0))
+ False
+ >>> a = (0, 0, 0)
+ >>> b = (1, 1, 1)
+ >>> c = (2, 2, 2)
+ >>> l1 = Line(a, b)
+ >>> l2 = Line(b, a)
+ >>> l1 == l2
+ False
+ >>> l1 in l2
+ True
+
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if isinstance(other, Point):
+ return Point.is_collinear(other, self.p1, self.p2)
+ if isinstance(other, LinearEntity):
+ return Point.is_collinear(self.p1, self.p2, other.p1, other.p2)
+ return False
+
+ def distance(self, other):
+ """
+ Finds the shortest distance between a line and a point.
+
+ Raises
+ ======
+
+ NotImplementedError is raised if `other` is not a Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(1, 1)
+ >>> s = Line(p1, p2)
+ >>> s.distance(Point(-1, 1))
+ sqrt(2)
+ >>> s.distance((-1, 2))
+ 3*sqrt(2)/2
+ >>> p1, p2 = Point(0, 0, 0), Point(1, 1, 1)
+ >>> s = Line(p1, p2)
+ >>> s.distance(Point(-1, 1, 1))
+ 2*sqrt(6)/3
+ >>> s.distance((-1, 1, 1))
+ 2*sqrt(6)/3
+
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if self.contains(other):
+ return S.Zero
+ return self.perpendicular_segment(other).length
+
+ def equals(self, other):
+ """Returns True if self and other are the same mathematical entities"""
+ if not isinstance(other, Line):
+ return False
+ return Point.is_collinear(self.p1, other.p1, self.p2, other.p2)
+
+ def plot_interval(self, parameter='t'):
+ """The plot interval for the default geometric plot of line. Gives
+ values that will produce a line that is +/- 5 units long (where a
+ unit is the distance between the two points that define the line).
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ Default value is 't'.
+
+ Returns
+ =======
+
+ plot_interval : list (plot interval)
+ [parameter, lower_bound, upper_bound]
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(5, 3)
+ >>> l1 = Line(p1, p2)
+ >>> l1.plot_interval()
+ [t, -5, 5]
+
+ """
+ t = _symbol(parameter, real=True)
+ return [t, -5, 5]
+
+
+class Ray(LinearEntity):
+ """A Ray is a semi-line in the space with a source point and a direction.
+
+ Parameters
+ ==========
+
+ p1 : Point
+ The source of the Ray
+ p2 : Point or radian value
+ This point determines the direction in which the Ray propagates.
+ If given as an angle it is interpreted in radians with the positive
+ direction being ccw.
+
+ Attributes
+ ==========
+
+ source
+
+ See Also
+ ========
+
+ sympy.geometry.line.Ray2D
+ sympy.geometry.line.Ray3D
+ sympy.geometry.point.Point
+ sympy.geometry.line.Line
+
+ Notes
+ =====
+
+ `Ray` will automatically subclass to `Ray2D` or `Ray3D` based on the
+ dimension of `p1`.
+
+ Examples
+ ========
+
+ >>> from sympy import Ray, Point, pi
+ >>> r = Ray(Point(2, 3), Point(3, 5))
+ >>> r
+ Ray2D(Point2D(2, 3), Point2D(3, 5))
+ >>> r.points
+ (Point2D(2, 3), Point2D(3, 5))
+ >>> r.source
+ Point2D(2, 3)
+ >>> r.xdirection
+ oo
+ >>> r.ydirection
+ oo
+ >>> r.slope
+ 2
+ >>> Ray(Point(0, 0), angle=pi/4).slope
+ 1
+
+ """
+ def __new__(cls, p1, p2=None, **kwargs):
+ p1 = Point(p1)
+ if p2 is not None:
+ p1, p2 = Point._normalize_dimension(p1, Point(p2))
+ dim = len(p1)
+
+ if dim == 2:
+ return Ray2D(p1, p2, **kwargs)
+ elif dim == 3:
+ return Ray3D(p1, p2, **kwargs)
+ return LinearEntity.__new__(cls, p1, p2, **kwargs)
+
+ def _svg(self, scale_factor=1., fill_color="#66cc99"):
+ """Returns SVG path element for the LinearEntity.
+
+ Parameters
+ ==========
+
+ scale_factor : float
+ Multiplication factor for the SVG stroke-width. Default is 1.
+ fill_color : str, optional
+ Hex string for fill color. Default is "#66cc99".
+ """
+ verts = (N(self.p1), N(self.p2))
+ coords = ["{},{}".format(p.x, p.y) for p in verts]
+ path = "M {} L {}".format(coords[0], " L ".join(coords[1:]))
+
+ return (
+ ''
+ ).format(2.*scale_factor, path, fill_color)
+
+ def contains(self, other):
+ """
+ Is other GeometryEntity contained in this Ray?
+
+ Examples
+ ========
+
+ >>> from sympy import Ray,Point,Segment
+ >>> p1, p2 = Point(0, 0), Point(4, 4)
+ >>> r = Ray(p1, p2)
+ >>> r.contains(p1)
+ True
+ >>> r.contains((1, 1))
+ True
+ >>> r.contains((1, 3))
+ False
+ >>> s = Segment((1, 1), (2, 2))
+ >>> r.contains(s)
+ True
+ >>> s = Segment((1, 2), (2, 5))
+ >>> r.contains(s)
+ False
+ >>> r1 = Ray((2, 2), (3, 3))
+ >>> r.contains(r1)
+ True
+ >>> r1 = Ray((2, 2), (3, 5))
+ >>> r.contains(r1)
+ False
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if isinstance(other, Point):
+ if Point.is_collinear(self.p1, self.p2, other):
+ # if we're in the direction of the ray, our
+ # direction vector dot the ray's direction vector
+ # should be non-negative
+ return bool((self.p2 - self.p1).dot(other - self.p1) >= S.Zero)
+ return False
+ elif isinstance(other, Ray):
+ if Point.is_collinear(self.p1, self.p2, other.p1, other.p2):
+ return bool((self.p2 - self.p1).dot(other.p2 - other.p1) > S.Zero)
+ return False
+ elif isinstance(other, Segment):
+ return other.p1 in self and other.p2 in self
+
+ # No other known entity can be contained in a Ray
+ return False
+
+ def distance(self, other):
+ """
+ Finds the shortest distance between the ray and a point.
+
+ Raises
+ ======
+
+ NotImplementedError is raised if `other` is not a Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ray
+ >>> p1, p2 = Point(0, 0), Point(1, 1)
+ >>> s = Ray(p1, p2)
+ >>> s.distance(Point(-1, -1))
+ sqrt(2)
+ >>> s.distance((-1, 2))
+ 3*sqrt(2)/2
+ >>> p1, p2 = Point(0, 0, 0), Point(1, 1, 2)
+ >>> s = Ray(p1, p2)
+ >>> s
+ Ray3D(Point3D(0, 0, 0), Point3D(1, 1, 2))
+ >>> s.distance(Point(-1, -1, 2))
+ 4*sqrt(3)/3
+ >>> s.distance((-1, -1, 2))
+ 4*sqrt(3)/3
+
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if self.contains(other):
+ return S.Zero
+
+ proj = Line(self.p1, self.p2).projection(other)
+ if self.contains(proj):
+ return abs(other - proj)
+ else:
+ return abs(other - self.source)
+
+ def equals(self, other):
+ """Returns True if self and other are the same mathematical entities"""
+ if not isinstance(other, Ray):
+ return False
+ return self.source == other.source and other.p2 in self
+
+ def plot_interval(self, parameter='t'):
+ """The plot interval for the default geometric plot of the Ray. Gives
+ values that will produce a ray that is 10 units long (where a unit is
+ the distance between the two points that define the ray).
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ Default value is 't'.
+
+ Returns
+ =======
+
+ plot_interval : list
+ [parameter, lower_bound, upper_bound]
+
+ Examples
+ ========
+
+ >>> from sympy import Ray, pi
+ >>> r = Ray((0, 0), angle=pi/4)
+ >>> r.plot_interval()
+ [t, 0, 10]
+
+ """
+ t = _symbol(parameter, real=True)
+ return [t, 0, 10]
+
+ @property
+ def source(self):
+ """The point from which the ray emanates.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ray
+ >>> p1, p2 = Point(0, 0), Point(4, 1)
+ >>> r1 = Ray(p1, p2)
+ >>> r1.source
+ Point2D(0, 0)
+ >>> p1, p2 = Point(0, 0, 0), Point(4, 1, 5)
+ >>> r1 = Ray(p2, p1)
+ >>> r1.source
+ Point3D(4, 1, 5)
+
+ """
+ return self.p1
+
+
+class Segment(LinearEntity):
+ """A line segment in space.
+
+ Parameters
+ ==========
+
+ p1 : Point
+ p2 : Point
+
+ Attributes
+ ==========
+
+ length : number or SymPy expression
+ midpoint : Point
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment2D
+ sympy.geometry.line.Segment3D
+ sympy.geometry.point.Point
+ sympy.geometry.line.Line
+
+ Notes
+ =====
+
+ If 2D or 3D points are used to define `Segment`, it will
+ be automatically subclassed to `Segment2D` or `Segment3D`.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> Segment((1, 0), (1, 1)) # tuples are interpreted as pts
+ Segment2D(Point2D(1, 0), Point2D(1, 1))
+ >>> s = Segment(Point(4, 3), Point(1, 1))
+ >>> s.points
+ (Point2D(4, 3), Point2D(1, 1))
+ >>> s.slope
+ 2/3
+ >>> s.length
+ sqrt(13)
+ >>> s.midpoint
+ Point2D(5/2, 2)
+ >>> Segment((1, 0, 0), (1, 1, 1)) # tuples are interpreted as pts
+ Segment3D(Point3D(1, 0, 0), Point3D(1, 1, 1))
+ >>> s = Segment(Point(4, 3, 9), Point(1, 1, 7)); s
+ Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7))
+ >>> s.points
+ (Point3D(4, 3, 9), Point3D(1, 1, 7))
+ >>> s.length
+ sqrt(17)
+ >>> s.midpoint
+ Point3D(5/2, 2, 8)
+
+ """
+ def __new__(cls, p1, p2, **kwargs):
+ p1, p2 = Point._normalize_dimension(Point(p1), Point(p2))
+ dim = len(p1)
+
+ if dim == 2:
+ return Segment2D(p1, p2, **kwargs)
+ elif dim == 3:
+ return Segment3D(p1, p2, **kwargs)
+ return LinearEntity.__new__(cls, p1, p2, **kwargs)
+
+ def contains(self, other):
+ """
+ Is the other GeometryEntity contained within this Segment?
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> p1, p2 = Point(0, 1), Point(3, 4)
+ >>> s = Segment(p1, p2)
+ >>> s2 = Segment(p2, p1)
+ >>> s.contains(s2)
+ True
+ >>> from sympy import Point3D, Segment3D
+ >>> p1, p2 = Point3D(0, 1, 1), Point3D(3, 4, 5)
+ >>> s = Segment3D(p1, p2)
+ >>> s2 = Segment3D(p2, p1)
+ >>> s.contains(s2)
+ True
+ >>> s.contains((p1 + p2)/2)
+ True
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if isinstance(other, Point):
+ if Point.is_collinear(other, self.p1, self.p2):
+ if isinstance(self, Segment2D):
+ # if it is collinear and is in the bounding box of the
+ # segment then it must be on the segment
+ vert = (1/self.slope).equals(0)
+ if vert is False:
+ isin = (self.p1.x - other.x)*(self.p2.x - other.x) <= 0
+ if isin in (True, False):
+ return isin
+ if vert is True:
+ isin = (self.p1.y - other.y)*(self.p2.y - other.y) <= 0
+ if isin in (True, False):
+ return isin
+ # use the triangle inequality
+ d1, d2 = other - self.p1, other - self.p2
+ d = self.p2 - self.p1
+ # without the call to simplify, SymPy cannot tell that an expression
+ # like (a+b)*(a/2+b/2) is always non-negative. If it cannot be
+ # determined, raise an Undecidable error
+ try:
+ # the triangle inequality says that |d1|+|d2| >= |d| and is strict
+ # only if other lies in the line segment
+ return bool(simplify(Eq(abs(d1) + abs(d2) - abs(d), 0)))
+ except TypeError:
+ raise Undecidable("Cannot determine if {} is in {}".format(other, self))
+ if isinstance(other, Segment):
+ return other.p1 in self and other.p2 in self
+
+ return False
+
+ def equals(self, other):
+ """Returns True if self and other are the same mathematical entities"""
+ return isinstance(other, self.func) and list(
+ ordered(self.args)) == list(ordered(other.args))
+
+ def distance(self, other):
+ """
+ Finds the shortest distance between a line segment and a point.
+
+ Raises
+ ======
+
+ NotImplementedError is raised if `other` is not a Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> p1, p2 = Point(0, 1), Point(3, 4)
+ >>> s = Segment(p1, p2)
+ >>> s.distance(Point(10, 15))
+ sqrt(170)
+ >>> s.distance((0, 12))
+ sqrt(73)
+ >>> from sympy import Point3D, Segment3D
+ >>> p1, p2 = Point3D(0, 0, 3), Point3D(1, 1, 4)
+ >>> s = Segment3D(p1, p2)
+ >>> s.distance(Point3D(10, 15, 12))
+ sqrt(341)
+ >>> s.distance((10, 15, 12))
+ sqrt(341)
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if isinstance(other, Point):
+ vp1 = other - self.p1
+ vp2 = other - self.p2
+
+ dot_prod_sign_1 = self.direction.dot(vp1) >= 0
+ dot_prod_sign_2 = self.direction.dot(vp2) <= 0
+ if dot_prod_sign_1 and dot_prod_sign_2:
+ return Line(self.p1, self.p2).distance(other)
+ if dot_prod_sign_1 and not dot_prod_sign_2:
+ return abs(vp2)
+ if not dot_prod_sign_1 and dot_prod_sign_2:
+ return abs(vp1)
+ raise NotImplementedError()
+
+ @property
+ def length(self):
+ """The length of the line segment.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.distance
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> p1, p2 = Point(0, 0), Point(4, 3)
+ >>> s1 = Segment(p1, p2)
+ >>> s1.length
+ 5
+ >>> from sympy import Point3D, Segment3D
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(4, 3, 3)
+ >>> s1 = Segment3D(p1, p2)
+ >>> s1.length
+ sqrt(34)
+
+ """
+ return Point.distance(self.p1, self.p2)
+
+ @property
+ def midpoint(self):
+ """The midpoint of the line segment.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.midpoint
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> p1, p2 = Point(0, 0), Point(4, 3)
+ >>> s1 = Segment(p1, p2)
+ >>> s1.midpoint
+ Point2D(2, 3/2)
+ >>> from sympy import Point3D, Segment3D
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(4, 3, 3)
+ >>> s1 = Segment3D(p1, p2)
+ >>> s1.midpoint
+ Point3D(2, 3/2, 3/2)
+
+ """
+ return Point.midpoint(self.p1, self.p2)
+
+ def perpendicular_bisector(self, p=None):
+ """The perpendicular bisector of this segment.
+
+ If no point is specified or the point specified is not on the
+ bisector then the bisector is returned as a Line. Otherwise a
+ Segment is returned that joins the point specified and the
+ intersection of the bisector and the segment.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ bisector : Line or Segment
+
+ See Also
+ ========
+
+ LinearEntity.perpendicular_segment
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> p1, p2, p3 = Point(0, 0), Point(6, 6), Point(5, 1)
+ >>> s1 = Segment(p1, p2)
+ >>> s1.perpendicular_bisector()
+ Line2D(Point2D(3, 3), Point2D(-3, 9))
+
+ >>> s1.perpendicular_bisector(p3)
+ Segment2D(Point2D(5, 1), Point2D(3, 3))
+
+ """
+ l = self.perpendicular_line(self.midpoint)
+ if p is not None:
+ p2 = Point(p, dim=self.ambient_dimension)
+ if p2 in l:
+ return Segment(p2, self.midpoint)
+ return l
+
+ def plot_interval(self, parameter='t'):
+ """The plot interval for the default geometric plot of the Segment gives
+ values that will produce the full segment in a plot.
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ Default value is 't'.
+
+ Returns
+ =======
+
+ plot_interval : list
+ [parameter, lower_bound, upper_bound]
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> p1, p2 = Point(0, 0), Point(5, 3)
+ >>> s1 = Segment(p1, p2)
+ >>> s1.plot_interval()
+ [t, 0, 1]
+
+ """
+ t = _symbol(parameter, real=True)
+ return [t, 0, 1]
+
+
+class LinearEntity2D(LinearEntity):
+ """A base class for all linear entities (line, ray and segment)
+ in a 2-dimensional Euclidean space.
+
+ Attributes
+ ==========
+
+ p1
+ p2
+ coefficients
+ slope
+ points
+
+ Notes
+ =====
+
+ This is an abstract class and is not meant to be instantiated.
+
+ See Also
+ ========
+
+ sympy.geometry.entity.GeometryEntity
+
+ """
+ @property
+ def bounds(self):
+ """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+ rectangle for the geometric figure.
+
+ """
+ verts = self.points
+ xs = [p.x for p in verts]
+ ys = [p.y for p in verts]
+ return (min(xs), min(ys), max(xs), max(ys))
+
+ def perpendicular_line(self, p):
+ """Create a new Line perpendicular to this linear entity which passes
+ through the point `p`.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ line : Line
+
+ See Also
+ ========
+
+ sympy.geometry.line.LinearEntity.is_perpendicular, perpendicular_segment
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2, p3 = Point(0, 0), Point(2, 3), Point(-2, 2)
+ >>> L = Line(p1, p2)
+ >>> P = L.perpendicular_line(p3); P
+ Line2D(Point2D(-2, 2), Point2D(-5, 4))
+ >>> L.is_perpendicular(P)
+ True
+
+ In 2D, the first point of the perpendicular line is the
+ point through which was required to pass; the second
+ point is arbitrarily chosen. To get a line that explicitly
+ uses a point in the line, create a line from the perpendicular
+ segment from the line to the point:
+
+ >>> Line(L.perpendicular_segment(p3))
+ Line2D(Point2D(-2, 2), Point2D(4/13, 6/13))
+ """
+ p = Point(p, dim=self.ambient_dimension)
+ # any two lines in R^2 intersect, so blindly making
+ # a line through p in an orthogonal direction will work
+ # and is faster than finding the projection point as in 3D
+ return Line(p, p + self.direction.orthogonal_direction)
+
+ @property
+ def slope(self):
+ """The slope of this linear entity, or infinity if vertical.
+
+ Returns
+ =======
+
+ slope : number or SymPy expression
+
+ See Also
+ ========
+
+ coefficients
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(3, 5)
+ >>> l1 = Line(p1, p2)
+ >>> l1.slope
+ 5/3
+
+ >>> p3 = Point(0, 4)
+ >>> l2 = Line(p1, p3)
+ >>> l2.slope
+ oo
+
+ """
+ d1, d2 = (self.p1 - self.p2).args
+ if d1 == 0:
+ return S.Infinity
+ return simplify(d2/d1)
+
+
+class Line2D(LinearEntity2D, Line):
+ """An infinite line in space 2D.
+
+ A line is declared with two distinct points or a point and slope
+ as defined using keyword `slope`.
+
+ Parameters
+ ==========
+
+ p1 : Point
+ pt : Point
+ slope : SymPy expression
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Line, Segment, Point
+ >>> L = Line(Point(2,3), Point(3,5))
+ >>> L
+ Line2D(Point2D(2, 3), Point2D(3, 5))
+ >>> L.points
+ (Point2D(2, 3), Point2D(3, 5))
+ >>> L.equation()
+ -2*x + y + 1
+ >>> L.coefficients
+ (-2, 1, 1)
+
+ Instantiate with keyword ``slope``:
+
+ >>> Line(Point(0, 0), slope=0)
+ Line2D(Point2D(0, 0), Point2D(1, 0))
+
+ Instantiate with another linear object
+
+ >>> s = Segment((0, 0), (0, 1))
+ >>> Line(s).equation()
+ x
+ """
+ def __new__(cls, p1, pt=None, slope=None, **kwargs):
+ if isinstance(p1, LinearEntity):
+ if pt is not None:
+ raise ValueError('When p1 is a LinearEntity, pt should be None')
+ p1, pt = Point._normalize_dimension(*p1.args, dim=2)
+ else:
+ p1 = Point(p1, dim=2)
+ if pt is not None and slope is None:
+ try:
+ p2 = Point(pt, dim=2)
+ except (NotImplementedError, TypeError, ValueError):
+ raise ValueError(filldedent('''
+ The 2nd argument was not a valid Point.
+ If it was a slope, enter it with keyword "slope".
+ '''))
+ elif slope is not None and pt is None:
+ slope = sympify(slope)
+ if slope.is_finite is False:
+ # when infinite slope, don't change x
+ dx = 0
+ dy = 1
+ else:
+ # go over 1 up slope
+ dx = 1
+ dy = slope
+ # XXX avoiding simplification by adding to coords directly
+ p2 = Point(p1.x + dx, p1.y + dy, evaluate=False)
+ else:
+ raise ValueError('A 2nd Point or keyword "slope" must be used.')
+ return LinearEntity2D.__new__(cls, p1, p2, **kwargs)
+
+ def _svg(self, scale_factor=1., fill_color="#66cc99"):
+ """Returns SVG path element for the LinearEntity.
+
+ Parameters
+ ==========
+
+ scale_factor : float
+ Multiplication factor for the SVG stroke-width. Default is 1.
+ fill_color : str, optional
+ Hex string for fill color. Default is "#66cc99".
+ """
+ verts = (N(self.p1), N(self.p2))
+ coords = ["{},{}".format(p.x, p.y) for p in verts]
+ path = "M {} L {}".format(coords[0], " L ".join(coords[1:]))
+
+ return (
+ ''
+ ).format(2.*scale_factor, path, fill_color)
+
+ @property
+ def coefficients(self):
+ """The coefficients (`a`, `b`, `c`) for `ax + by + c = 0`.
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line2D.equation
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> from sympy.abc import x, y
+ >>> p1, p2 = Point(0, 0), Point(5, 3)
+ >>> l = Line(p1, p2)
+ >>> l.coefficients
+ (-3, 5, 0)
+
+ >>> p3 = Point(x, y)
+ >>> l2 = Line(p1, p3)
+ >>> l2.coefficients
+ (-y, x, 0)
+
+ """
+ p1, p2 = self.points
+ if p1.x == p2.x:
+ return (S.One, S.Zero, -p1.x)
+ elif p1.y == p2.y:
+ return (S.Zero, S.One, -p1.y)
+ return tuple([simplify(i) for i in
+ (self.p1.y - self.p2.y,
+ self.p2.x - self.p1.x,
+ self.p1.x*self.p2.y - self.p1.y*self.p2.x)])
+
+ def equation(self, x='x', y='y'):
+ """The equation of the line: ax + by + c.
+
+ Parameters
+ ==========
+
+ x : str, optional
+ The name to use for the x-axis, default value is 'x'.
+ y : str, optional
+ The name to use for the y-axis, default value is 'y'.
+
+ Returns
+ =======
+
+ equation : SymPy expression
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line2D.coefficients
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(1, 0), Point(5, 3)
+ >>> l1 = Line(p1, p2)
+ >>> l1.equation()
+ -3*x + 4*y + 3
+
+ """
+ x = _symbol(x, real=True)
+ y = _symbol(y, real=True)
+ p1, p2 = self.points
+ if p1.x == p2.x:
+ return x - p1.x
+ elif p1.y == p2.y:
+ return y - p1.y
+
+ a, b, c = self.coefficients
+ return a*x + b*y + c
+
+
+class Ray2D(LinearEntity2D, Ray):
+ """
+ A Ray is a semi-line in the space with a source point and a direction.
+
+ Parameters
+ ==========
+
+ p1 : Point
+ The source of the Ray
+ p2 : Point or radian value
+ This point determines the direction in which the Ray propagates.
+ If given as an angle it is interpreted in radians with the positive
+ direction being ccw.
+
+ Attributes
+ ==========
+
+ source
+ xdirection
+ ydirection
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, Line
+
+ Examples
+ ========
+
+ >>> from sympy import Point, pi, Ray
+ >>> r = Ray(Point(2, 3), Point(3, 5))
+ >>> r
+ Ray2D(Point2D(2, 3), Point2D(3, 5))
+ >>> r.points
+ (Point2D(2, 3), Point2D(3, 5))
+ >>> r.source
+ Point2D(2, 3)
+ >>> r.xdirection
+ oo
+ >>> r.ydirection
+ oo
+ >>> r.slope
+ 2
+ >>> Ray(Point(0, 0), angle=pi/4).slope
+ 1
+
+ """
+ def __new__(cls, p1, pt=None, angle=None, **kwargs):
+ p1 = Point(p1, dim=2)
+ if pt is not None and angle is None:
+ try:
+ p2 = Point(pt, dim=2)
+ except (NotImplementedError, TypeError, ValueError):
+ raise ValueError(filldedent('''
+ The 2nd argument was not a valid Point; if
+ it was meant to be an angle it should be
+ given with keyword "angle".'''))
+ if p1 == p2:
+ raise ValueError('A Ray requires two distinct points.')
+ elif angle is not None and pt is None:
+ # we need to know if the angle is an odd multiple of pi/2
+ angle = sympify(angle)
+ c = _pi_coeff(angle)
+ p2 = None
+ if c is not None:
+ if c.is_Rational:
+ if c.q == 2:
+ if c.p == 1:
+ p2 = p1 + Point(0, 1)
+ elif c.p == 3:
+ p2 = p1 + Point(0, -1)
+ elif c.q == 1:
+ if c.p == 0:
+ p2 = p1 + Point(1, 0)
+ elif c.p == 1:
+ p2 = p1 + Point(-1, 0)
+ if p2 is None:
+ c *= S.Pi
+ else:
+ c = angle % (2*S.Pi)
+ if not p2:
+ m = 2*c/S.Pi
+ left = And(1 < m, m < 3) # is it in quadrant 2 or 3?
+ x = Piecewise((-1, left), (Piecewise((0, Eq(m % 1, 0)), (1, True)), True))
+ y = Piecewise((-tan(c), left), (Piecewise((1, Eq(m, 1)), (-1, Eq(m, 3)), (tan(c), True)), True))
+ p2 = p1 + Point(x, y)
+ else:
+ raise ValueError('A 2nd point or keyword "angle" must be used.')
+
+ return LinearEntity2D.__new__(cls, p1, p2, **kwargs)
+
+ @property
+ def xdirection(self):
+ """The x direction of the ray.
+
+ Positive infinity if the ray points in the positive x direction,
+ negative infinity if the ray points in the negative x direction,
+ or 0 if the ray is vertical.
+
+ See Also
+ ========
+
+ ydirection
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ray
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, -1)
+ >>> r1, r2 = Ray(p1, p2), Ray(p1, p3)
+ >>> r1.xdirection
+ oo
+ >>> r2.xdirection
+ 0
+
+ """
+ if self.p1.x < self.p2.x:
+ return S.Infinity
+ elif self.p1.x == self.p2.x:
+ return S.Zero
+ else:
+ return S.NegativeInfinity
+
+ @property
+ def ydirection(self):
+ """The y direction of the ray.
+
+ Positive infinity if the ray points in the positive y direction,
+ negative infinity if the ray points in the negative y direction,
+ or 0 if the ray is horizontal.
+
+ See Also
+ ========
+
+ xdirection
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ray
+ >>> p1, p2, p3 = Point(0, 0), Point(-1, -1), Point(-1, 0)
+ >>> r1, r2 = Ray(p1, p2), Ray(p1, p3)
+ >>> r1.ydirection
+ -oo
+ >>> r2.ydirection
+ 0
+
+ """
+ if self.p1.y < self.p2.y:
+ return S.Infinity
+ elif self.p1.y == self.p2.y:
+ return S.Zero
+ else:
+ return S.NegativeInfinity
+
+ def closing_angle(r1, r2):
+ """Return the angle by which r2 must be rotated so it faces the same
+ direction as r1.
+
+ Parameters
+ ==========
+
+ r1 : Ray2D
+ r2 : Ray2D
+
+ Returns
+ =======
+
+ angle : angle in radians (ccw angle is positive)
+
+ See Also
+ ========
+
+ LinearEntity.angle_between
+
+ Examples
+ ========
+
+ >>> from sympy import Ray, pi
+ >>> r1 = Ray((0, 0), (1, 0))
+ >>> r2 = r1.rotate(-pi/2)
+ >>> angle = r1.closing_angle(r2); angle
+ pi/2
+ >>> r2.rotate(angle).direction.unit == r1.direction.unit
+ True
+ >>> r2.closing_angle(r1)
+ -pi/2
+ """
+ if not all(isinstance(r, Ray2D) for r in (r1, r2)):
+ # although the direction property is defined for
+ # all linear entities, only the Ray is truly a
+ # directed object
+ raise TypeError('Both arguments must be Ray2D objects.')
+
+ a1 = atan2(*list(reversed(r1.direction.args)))
+ a2 = atan2(*list(reversed(r2.direction.args)))
+ if a1*a2 < 0:
+ a1 = 2*S.Pi + a1 if a1 < 0 else a1
+ a2 = 2*S.Pi + a2 if a2 < 0 else a2
+ return a1 - a2
+
+
+class Segment2D(LinearEntity2D, Segment):
+ """A line segment in 2D space.
+
+ Parameters
+ ==========
+
+ p1 : Point
+ p2 : Point
+
+ Attributes
+ ==========
+
+ length : number or SymPy expression
+ midpoint : Point
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, Line
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> Segment((1, 0), (1, 1)) # tuples are interpreted as pts
+ Segment2D(Point2D(1, 0), Point2D(1, 1))
+ >>> s = Segment(Point(4, 3), Point(1, 1)); s
+ Segment2D(Point2D(4, 3), Point2D(1, 1))
+ >>> s.points
+ (Point2D(4, 3), Point2D(1, 1))
+ >>> s.slope
+ 2/3
+ >>> s.length
+ sqrt(13)
+ >>> s.midpoint
+ Point2D(5/2, 2)
+
+ """
+ def __new__(cls, p1, p2, **kwargs):
+ p1 = Point(p1, dim=2)
+ p2 = Point(p2, dim=2)
+
+ if p1 == p2:
+ return p1
+
+ return LinearEntity2D.__new__(cls, p1, p2, **kwargs)
+
+ def _svg(self, scale_factor=1., fill_color="#66cc99"):
+ """Returns SVG path element for the LinearEntity.
+
+ Parameters
+ ==========
+
+ scale_factor : float
+ Multiplication factor for the SVG stroke-width. Default is 1.
+ fill_color : str, optional
+ Hex string for fill color. Default is "#66cc99".
+ """
+ verts = (N(self.p1), N(self.p2))
+ coords = ["{},{}".format(p.x, p.y) for p in verts]
+ path = "M {} L {}".format(coords[0], " L ".join(coords[1:]))
+ return (
+ ''
+ ).format(2.*scale_factor, path, fill_color)
+
+
+class LinearEntity3D(LinearEntity):
+ """An base class for all linear entities (line, ray and segment)
+ in a 3-dimensional Euclidean space.
+
+ Attributes
+ ==========
+
+ p1
+ p2
+ direction_ratio
+ direction_cosine
+ points
+
+ Notes
+ =====
+
+ This is a base class and is not meant to be instantiated.
+ """
+ def __new__(cls, p1, p2, **kwargs):
+ p1 = Point3D(p1, dim=3)
+ p2 = Point3D(p2, dim=3)
+ if p1 == p2:
+ # if it makes sense to return a Point, handle in subclass
+ raise ValueError(
+ "%s.__new__ requires two unique Points." % cls.__name__)
+
+ return GeometryEntity.__new__(cls, p1, p2, **kwargs)
+
+ ambient_dimension = 3
+
+ @property
+ def direction_ratio(self):
+ """The direction ratio of a given line in 3D.
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line3D.equation
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(5, 3, 1)
+ >>> l = Line3D(p1, p2)
+ >>> l.direction_ratio
+ [5, 3, 1]
+ """
+ p1, p2 = self.points
+ return p1.direction_ratio(p2)
+
+ @property
+ def direction_cosine(self):
+ """The normalized direction ratio of a given line in 3D.
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line3D.equation
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(5, 3, 1)
+ >>> l = Line3D(p1, p2)
+ >>> l.direction_cosine
+ [sqrt(35)/7, 3*sqrt(35)/35, sqrt(35)/35]
+ >>> sum(i**2 for i in _)
+ 1
+ """
+ p1, p2 = self.points
+ return p1.direction_cosine(p2)
+
+
+class Line3D(LinearEntity3D, Line):
+ """An infinite 3D line in space.
+
+ A line is declared with two distinct points or a point and direction_ratio
+ as defined using keyword `direction_ratio`.
+
+ Parameters
+ ==========
+
+ p1 : Point3D
+ pt : Point3D
+ direction_ratio : list
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point3D
+ sympy.geometry.line.Line
+ sympy.geometry.line.Line2D
+
+ Examples
+ ========
+
+ >>> from sympy import Line3D, Point3D
+ >>> L = Line3D(Point3D(2, 3, 4), Point3D(3, 5, 1))
+ >>> L
+ Line3D(Point3D(2, 3, 4), Point3D(3, 5, 1))
+ >>> L.points
+ (Point3D(2, 3, 4), Point3D(3, 5, 1))
+ """
+ def __new__(cls, p1, pt=None, direction_ratio=(), **kwargs):
+ if isinstance(p1, LinearEntity3D):
+ if pt is not None:
+ raise ValueError('if p1 is a LinearEntity, pt must be None.')
+ p1, pt = p1.args
+ else:
+ p1 = Point(p1, dim=3)
+ if pt is not None and len(direction_ratio) == 0:
+ pt = Point(pt, dim=3)
+ elif len(direction_ratio) == 3 and pt is None:
+ pt = Point3D(p1.x + direction_ratio[0], p1.y + direction_ratio[1],
+ p1.z + direction_ratio[2])
+ else:
+ raise ValueError('A 2nd Point or keyword "direction_ratio" must '
+ 'be used.')
+
+ return LinearEntity3D.__new__(cls, p1, pt, **kwargs)
+
+ def equation(self, x='x', y='y', z='z'):
+ """Return the equations that define the line in 3D.
+
+ Parameters
+ ==========
+
+ x : str, optional
+ The name to use for the x-axis, default value is 'x'.
+ y : str, optional
+ The name to use for the y-axis, default value is 'y'.
+ z : str, optional
+ The name to use for the z-axis, default value is 'z'.
+
+ Returns
+ =======
+
+ equation : Tuple of simultaneous equations
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D, solve
+ >>> from sympy.abc import x, y, z
+ >>> p1, p2 = Point3D(1, 0, 0), Point3D(5, 3, 0)
+ >>> l1 = Line3D(p1, p2)
+ >>> eq = l1.equation(x, y, z); eq
+ (-3*x + 4*y + 3, z)
+ >>> solve(eq.subs(z, 0), (x, y, z))
+ {x: 4*y/3 + 1}
+ """
+ x, y, z, k = [_symbol(i, real=True) for i in (x, y, z, 'k')]
+ p1, p2 = self.points
+ d1, d2, d3 = p1.direction_ratio(p2)
+ x1, y1, z1 = p1
+ eqs = [-d1*k + x - x1, -d2*k + y - y1, -d3*k + z - z1]
+ # eliminate k from equations by solving first eq with k for k
+ for i, e in enumerate(eqs):
+ if e.has(k):
+ kk = solve(eqs[i], k)[0]
+ eqs.pop(i)
+ break
+ return Tuple(*[i.subs(k, kk).as_numer_denom()[0] for i in eqs])
+
+
+class Ray3D(LinearEntity3D, Ray):
+ """
+ A Ray is a semi-line in the space with a source point and a direction.
+
+ Parameters
+ ==========
+
+ p1 : Point3D
+ The source of the Ray
+ p2 : Point or a direction vector
+ direction_ratio: Determines the direction in which the Ray propagates.
+
+
+ Attributes
+ ==========
+
+ source
+ xdirection
+ ydirection
+ zdirection
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point3D, Line3D
+
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Ray3D
+ >>> r = Ray3D(Point3D(2, 3, 4), Point3D(3, 5, 0))
+ >>> r
+ Ray3D(Point3D(2, 3, 4), Point3D(3, 5, 0))
+ >>> r.points
+ (Point3D(2, 3, 4), Point3D(3, 5, 0))
+ >>> r.source
+ Point3D(2, 3, 4)
+ >>> r.xdirection
+ oo
+ >>> r.ydirection
+ oo
+ >>> r.direction_ratio
+ [1, 2, -4]
+
+ """
+ def __new__(cls, p1, pt=None, direction_ratio=(), **kwargs):
+ if isinstance(p1, LinearEntity3D):
+ if pt is not None:
+ raise ValueError('If p1 is a LinearEntity, pt must be None')
+ p1, pt = p1.args
+ else:
+ p1 = Point(p1, dim=3)
+ if pt is not None and len(direction_ratio) == 0:
+ pt = Point(pt, dim=3)
+ elif len(direction_ratio) == 3 and pt is None:
+ pt = Point3D(p1.x + direction_ratio[0], p1.y + direction_ratio[1],
+ p1.z + direction_ratio[2])
+ else:
+ raise ValueError(filldedent('''
+ A 2nd Point or keyword "direction_ratio" must be used.
+ '''))
+
+ return LinearEntity3D.__new__(cls, p1, pt, **kwargs)
+
+ @property
+ def xdirection(self):
+ """The x direction of the ray.
+
+ Positive infinity if the ray points in the positive x direction,
+ negative infinity if the ray points in the negative x direction,
+ or 0 if the ray is vertical.
+
+ See Also
+ ========
+
+ ydirection
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Ray3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, -1, 0)
+ >>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
+ >>> r1.xdirection
+ oo
+ >>> r2.xdirection
+ 0
+
+ """
+ if self.p1.x < self.p2.x:
+ return S.Infinity
+ elif self.p1.x == self.p2.x:
+ return S.Zero
+ else:
+ return S.NegativeInfinity
+
+ @property
+ def ydirection(self):
+ """The y direction of the ray.
+
+ Positive infinity if the ray points in the positive y direction,
+ negative infinity if the ray points in the negative y direction,
+ or 0 if the ray is horizontal.
+
+ See Also
+ ========
+
+ xdirection
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Ray3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(-1, -1, -1), Point3D(-1, 0, 0)
+ >>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
+ >>> r1.ydirection
+ -oo
+ >>> r2.ydirection
+ 0
+
+ """
+ if self.p1.y < self.p2.y:
+ return S.Infinity
+ elif self.p1.y == self.p2.y:
+ return S.Zero
+ else:
+ return S.NegativeInfinity
+
+ @property
+ def zdirection(self):
+ """The z direction of the ray.
+
+ Positive infinity if the ray points in the positive z direction,
+ negative infinity if the ray points in the negative z direction,
+ or 0 if the ray is horizontal.
+
+ See Also
+ ========
+
+ xdirection
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Ray3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(-1, -1, -1), Point3D(-1, 0, 0)
+ >>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
+ >>> r1.ydirection
+ -oo
+ >>> r2.ydirection
+ 0
+ >>> r2.zdirection
+ 0
+
+ """
+ if self.p1.z < self.p2.z:
+ return S.Infinity
+ elif self.p1.z == self.p2.z:
+ return S.Zero
+ else:
+ return S.NegativeInfinity
+
+
+class Segment3D(LinearEntity3D, Segment):
+ """A line segment in a 3D space.
+
+ Parameters
+ ==========
+
+ p1 : Point3D
+ p2 : Point3D
+
+ Attributes
+ ==========
+
+ length : number or SymPy expression
+ midpoint : Point3D
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point3D, Line3D
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Segment3D
+ >>> Segment3D((1, 0, 0), (1, 1, 1)) # tuples are interpreted as pts
+ Segment3D(Point3D(1, 0, 0), Point3D(1, 1, 1))
+ >>> s = Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7)); s
+ Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7))
+ >>> s.points
+ (Point3D(4, 3, 9), Point3D(1, 1, 7))
+ >>> s.length
+ sqrt(17)
+ >>> s.midpoint
+ Point3D(5/2, 2, 8)
+
+ """
+ def __new__(cls, p1, p2, **kwargs):
+ p1 = Point(p1, dim=3)
+ p2 = Point(p2, dim=3)
+
+ if p1 == p2:
+ return p1
+
+ return LinearEntity3D.__new__(cls, p1, p2, **kwargs)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/parabola.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/parabola.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b5a3c03fbc9f7b3e2e76538f38d1063539130ae
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/parabola.py
@@ -0,0 +1,422 @@
+"""Parabolic geometrical entity.
+
+Contains
+* Parabola
+
+"""
+
+from sympy.core import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import _symbol, symbols
+from sympy.geometry.entity import GeometryEntity, GeometrySet
+from sympy.geometry.point import Point, Point2D
+from sympy.geometry.line import Line, Line2D, Ray2D, Segment2D, LinearEntity3D
+from sympy.geometry.ellipse import Ellipse
+from sympy.functions import sign
+from sympy.simplify import simplify
+from sympy.solvers.solvers import solve
+
+
+class Parabola(GeometrySet):
+ """A parabolic GeometryEntity.
+
+ A parabola is declared with a point, that is called 'focus', and
+ a line, that is called 'directrix'.
+ Only vertical or horizontal parabolas are currently supported.
+
+ Parameters
+ ==========
+
+ focus : Point
+ Default value is Point(0, 0)
+ directrix : Line
+
+ Attributes
+ ==========
+
+ focus
+ directrix
+ axis of symmetry
+ focal length
+ p parameter
+ vertex
+ eccentricity
+
+ Raises
+ ======
+ ValueError
+ When `focus` is not a two dimensional point.
+ When `focus` is a point of directrix.
+ NotImplementedError
+ When `directrix` is neither horizontal nor vertical.
+
+ Examples
+ ========
+
+ >>> from sympy import Parabola, Point, Line
+ >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7,8)))
+ >>> p1.focus
+ Point2D(0, 0)
+ >>> p1.directrix
+ Line2D(Point2D(5, 8), Point2D(7, 8))
+
+ """
+
+ def __new__(cls, focus=None, directrix=None, **kwargs):
+
+ if focus:
+ focus = Point(focus, dim=2)
+ else:
+ focus = Point(0, 0)
+
+ directrix = Line(directrix)
+
+ if directrix.contains(focus):
+ raise ValueError('The focus must not be a point of directrix')
+
+ return GeometryEntity.__new__(cls, focus, directrix, **kwargs)
+
+ @property
+ def ambient_dimension(self):
+ """Returns the ambient dimension of parabola.
+
+ Returns
+ =======
+
+ ambient_dimension : integer
+
+ Examples
+ ========
+
+ >>> from sympy import Parabola, Point, Line
+ >>> f1 = Point(0, 0)
+ >>> p1 = Parabola(f1, Line(Point(5, 8), Point(7, 8)))
+ >>> p1.ambient_dimension
+ 2
+
+ """
+ return 2
+
+ @property
+ def axis_of_symmetry(self):
+ """Return the axis of symmetry of the parabola: a line
+ perpendicular to the directrix passing through the focus.
+
+ Returns
+ =======
+
+ axis_of_symmetry : Line
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line
+
+ Examples
+ ========
+
+ >>> from sympy import Parabola, Point, Line
+ >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+ >>> p1.axis_of_symmetry
+ Line2D(Point2D(0, 0), Point2D(0, 1))
+
+ """
+ return self.directrix.perpendicular_line(self.focus)
+
+ @property
+ def directrix(self):
+ """The directrix of the parabola.
+
+ Returns
+ =======
+
+ directrix : Line
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line
+
+ Examples
+ ========
+
+ >>> from sympy import Parabola, Point, Line
+ >>> l1 = Line(Point(5, 8), Point(7, 8))
+ >>> p1 = Parabola(Point(0, 0), l1)
+ >>> p1.directrix
+ Line2D(Point2D(5, 8), Point2D(7, 8))
+
+ """
+ return self.args[1]
+
+ @property
+ def eccentricity(self):
+ """The eccentricity of the parabola.
+
+ Returns
+ =======
+
+ eccentricity : number
+
+ A parabola may also be characterized as a conic section with an
+ eccentricity of 1. As a consequence of this, all parabolas are
+ similar, meaning that while they can be different sizes,
+ they are all the same shape.
+
+ See Also
+ ========
+
+ https://en.wikipedia.org/wiki/Parabola
+
+
+ Examples
+ ========
+
+ >>> from sympy import Parabola, Point, Line
+ >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+ >>> p1.eccentricity
+ 1
+
+ Notes
+ -----
+ The eccentricity for every Parabola is 1 by definition.
+
+ """
+ return S.One
+
+ def equation(self, x='x', y='y'):
+ """The equation of the parabola.
+
+ Parameters
+ ==========
+ x : str, optional
+ Label for the x-axis. Default value is 'x'.
+ y : str, optional
+ Label for the y-axis. Default value is 'y'.
+
+ Returns
+ =======
+ equation : SymPy expression
+
+ Examples
+ ========
+
+ >>> from sympy import Parabola, Point, Line
+ >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+ >>> p1.equation()
+ -x**2 - 16*y + 64
+ >>> p1.equation('f')
+ -f**2 - 16*y + 64
+ >>> p1.equation(y='z')
+ -x**2 - 16*z + 64
+
+ """
+ x = _symbol(x, real=True)
+ y = _symbol(y, real=True)
+
+ m = self.directrix.slope
+ if m is S.Infinity:
+ t1 = 4 * (self.p_parameter) * (x - self.vertex.x)
+ t2 = (y - self.vertex.y)**2
+ elif m == 0:
+ t1 = 4 * (self.p_parameter) * (y - self.vertex.y)
+ t2 = (x - self.vertex.x)**2
+ else:
+ a, b = self.focus
+ c, d = self.directrix.coefficients[:2]
+ t1 = (x - a)**2 + (y - b)**2
+ t2 = self.directrix.equation(x, y)**2/(c**2 + d**2)
+ return t1 - t2
+
+ @property
+ def focal_length(self):
+ """The focal length of the parabola.
+
+ Returns
+ =======
+
+ focal_lenght : number or symbolic expression
+
+ Notes
+ =====
+
+ The distance between the vertex and the focus
+ (or the vertex and directrix), measured along the axis
+ of symmetry, is the "focal length".
+
+ See Also
+ ========
+
+ https://en.wikipedia.org/wiki/Parabola
+
+ Examples
+ ========
+
+ >>> from sympy import Parabola, Point, Line
+ >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+ >>> p1.focal_length
+ 4
+
+ """
+ distance = self.directrix.distance(self.focus)
+ focal_length = distance/2
+
+ return focal_length
+
+ @property
+ def focus(self):
+ """The focus of the parabola.
+
+ Returns
+ =======
+
+ focus : Point
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Parabola, Point, Line
+ >>> f1 = Point(0, 0)
+ >>> p1 = Parabola(f1, Line(Point(5, 8), Point(7, 8)))
+ >>> p1.focus
+ Point2D(0, 0)
+
+ """
+ return self.args[0]
+
+ def intersection(self, o):
+ """The intersection of the parabola and another geometrical entity `o`.
+
+ Parameters
+ ==========
+
+ o : GeometryEntity, LinearEntity
+
+ Returns
+ =======
+
+ intersection : list of GeometryEntity objects
+
+ Examples
+ ========
+
+ >>> from sympy import Parabola, Point, Ellipse, Line, Segment
+ >>> p1 = Point(0,0)
+ >>> l1 = Line(Point(1, -2), Point(-1,-2))
+ >>> parabola1 = Parabola(p1, l1)
+ >>> parabola1.intersection(Ellipse(Point(0, 0), 2, 5))
+ [Point2D(-2, 0), Point2D(2, 0)]
+ >>> parabola1.intersection(Line(Point(-7, 3), Point(12, 3)))
+ [Point2D(-4, 3), Point2D(4, 3)]
+ >>> parabola1.intersection(Segment((-12, -65), (14, -68)))
+ []
+
+ """
+ x, y = symbols('x y', real=True)
+ parabola_eq = self.equation()
+ if isinstance(o, Parabola):
+ if o in self:
+ return [o]
+ else:
+ return list(ordered([Point(i) for i in solve(
+ [parabola_eq, o.equation()], [x, y], set=True)[1]]))
+ elif isinstance(o, Point2D):
+ if simplify(parabola_eq.subs([(x, o._args[0]), (y, o._args[1])])) == 0:
+ return [o]
+ else:
+ return []
+ elif isinstance(o, (Segment2D, Ray2D)):
+ result = solve([parabola_eq,
+ Line2D(o.points[0], o.points[1]).equation()],
+ [x, y], set=True)[1]
+ return list(ordered([Point2D(i) for i in result if i in o]))
+ elif isinstance(o, (Line2D, Ellipse)):
+ return list(ordered([Point2D(i) for i in solve(
+ [parabola_eq, o.equation()], [x, y], set=True)[1]]))
+ elif isinstance(o, LinearEntity3D):
+ raise TypeError('Entity must be two dimensional, not three dimensional')
+ else:
+ raise TypeError('Wrong type of argument were put')
+
+ @property
+ def p_parameter(self):
+ """P is a parameter of parabola.
+
+ Returns
+ =======
+
+ p : number or symbolic expression
+
+ Notes
+ =====
+
+ The absolute value of p is the focal length. The sign on p tells
+ which way the parabola faces. Vertical parabolas that open up
+ and horizontal that open right, give a positive value for p.
+ Vertical parabolas that open down and horizontal that open left,
+ give a negative value for p.
+
+
+ See Also
+ ========
+
+ https://www.sparknotes.com/math/precalc/conicsections/section2/
+
+ Examples
+ ========
+
+ >>> from sympy import Parabola, Point, Line
+ >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+ >>> p1.p_parameter
+ -4
+
+ """
+ m = self.directrix.slope
+ if m is S.Infinity:
+ x = self.directrix.coefficients[2]
+ p = sign(self.focus.args[0] + x)
+ elif m == 0:
+ y = self.directrix.coefficients[2]
+ p = sign(self.focus.args[1] + y)
+ else:
+ d = self.directrix.projection(self.focus)
+ p = sign(self.focus.x - d.x)
+ return p * self.focal_length
+
+ @property
+ def vertex(self):
+ """The vertex of the parabola.
+
+ Returns
+ =======
+
+ vertex : Point
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Parabola, Point, Line
+ >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+ >>> p1.vertex
+ Point2D(0, 4)
+
+ """
+ focus = self.focus
+ m = self.directrix.slope
+ if m is S.Infinity:
+ vertex = Point(focus.args[0] - self.p_parameter, focus.args[1])
+ elif m == 0:
+ vertex = Point(focus.args[0], focus.args[1] - self.p_parameter)
+ else:
+ vertex = self.axis_of_symmetry.intersection(self)[0]
+ return vertex
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/plane.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/plane.py
new file mode 100644
index 0000000000000000000000000000000000000000..aecb320068815e5425574c7a6cf5c01659fa2b10
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/plane.py
@@ -0,0 +1,884 @@
+"""Geometrical Planes.
+
+Contains
+========
+Plane
+
+"""
+
+from sympy.core import Dummy, Rational, S, Symbol
+from sympy.core.symbol import _symbol
+from sympy.functions.elementary.trigonometric import cos, sin, acos, asin, sqrt
+from .entity import GeometryEntity
+from .line import (Line, Ray, Segment, Line3D, LinearEntity, LinearEntity3D,
+ Ray3D, Segment3D)
+from .point import Point, Point3D
+from sympy.matrices import Matrix
+from sympy.polys.polytools import cancel
+from sympy.solvers import solve, linsolve
+from sympy.utilities.iterables import uniq, is_sequence
+from sympy.utilities.misc import filldedent, func_name, Undecidable
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+import random
+
+
+x, y, z, t = [Dummy('plane_dummy') for i in range(4)]
+
+
+class Plane(GeometryEntity):
+ """
+ A plane is a flat, two-dimensional surface. A plane is the two-dimensional
+ analogue of a point (zero-dimensions), a line (one-dimension) and a solid
+ (three-dimensions). A plane can generally be constructed by two types of
+ inputs. They are three non-collinear points and a point and the plane's
+ normal vector.
+
+ Attributes
+ ==========
+
+ p1
+ normal_vector
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
+ Plane(Point3D(1, 1, 1), (-1, 2, -1))
+ >>> Plane((1, 1, 1), (2, 3, 4), (2, 2, 2))
+ Plane(Point3D(1, 1, 1), (-1, 2, -1))
+ >>> Plane(Point3D(1, 1, 1), normal_vector=(1,4,7))
+ Plane(Point3D(1, 1, 1), (1, 4, 7))
+
+ """
+ def __new__(cls, p1, a=None, b=None, **kwargs):
+ p1 = Point3D(p1, dim=3)
+ if a and b:
+ p2 = Point(a, dim=3)
+ p3 = Point(b, dim=3)
+ if Point3D.are_collinear(p1, p2, p3):
+ raise ValueError('Enter three non-collinear points')
+ a = p1.direction_ratio(p2)
+ b = p1.direction_ratio(p3)
+ normal_vector = tuple(Matrix(a).cross(Matrix(b)))
+ else:
+ a = kwargs.pop('normal_vector', a)
+ evaluate = kwargs.get('evaluate', True)
+ if is_sequence(a) and len(a) == 3:
+ normal_vector = Point3D(a).args if evaluate else a
+ else:
+ raise ValueError(filldedent('''
+ Either provide 3 3D points or a point with a
+ normal vector expressed as a sequence of length 3'''))
+ if all(coord.is_zero for coord in normal_vector):
+ raise ValueError('Normal vector cannot be zero vector')
+ return GeometryEntity.__new__(cls, p1, normal_vector, **kwargs)
+
+ def __contains__(self, o):
+ k = self.equation(x, y, z)
+ if isinstance(o, (LinearEntity, LinearEntity3D)):
+ d = Point3D(o.arbitrary_point(t))
+ e = k.subs([(x, d.x), (y, d.y), (z, d.z)])
+ return e.equals(0)
+ try:
+ o = Point(o, dim=3, strict=True)
+ d = k.xreplace(dict(zip((x, y, z), o.args)))
+ return d.equals(0)
+ except TypeError:
+ return False
+
+ def _eval_evalf(self, prec=15, **options):
+ pt, tup = self.args
+ dps = prec_to_dps(prec)
+ pt = pt.evalf(n=dps, **options)
+ tup = tuple([i.evalf(n=dps, **options) for i in tup])
+ return self.func(pt, normal_vector=tup, evaluate=False)
+
+ def angle_between(self, o):
+ """Angle between the plane and other geometric entity.
+
+ Parameters
+ ==========
+
+ LinearEntity3D, Plane.
+
+ Returns
+ =======
+
+ angle : angle in radians
+
+ Notes
+ =====
+
+ This method accepts only 3D entities as it's parameter, but if you want
+ to calculate the angle between a 2D entity and a plane you should
+ first convert to a 3D entity by projecting onto a desired plane and
+ then proceed to calculate the angle.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D, Plane
+ >>> a = Plane(Point3D(1, 2, 2), normal_vector=(1, 2, 3))
+ >>> b = Line3D(Point3D(1, 3, 4), Point3D(2, 2, 2))
+ >>> a.angle_between(b)
+ -asin(sqrt(21)/6)
+
+ """
+ if isinstance(o, LinearEntity3D):
+ a = Matrix(self.normal_vector)
+ b = Matrix(o.direction_ratio)
+ c = a.dot(b)
+ d = sqrt(sum([i**2 for i in self.normal_vector]))
+ e = sqrt(sum([i**2 for i in o.direction_ratio]))
+ return asin(c/(d*e))
+ if isinstance(o, Plane):
+ a = Matrix(self.normal_vector)
+ b = Matrix(o.normal_vector)
+ c = a.dot(b)
+ d = sqrt(sum([i**2 for i in self.normal_vector]))
+ e = sqrt(sum([i**2 for i in o.normal_vector]))
+ return acos(c/(d*e))
+
+
+ def arbitrary_point(self, u=None, v=None):
+ """ Returns an arbitrary point on the Plane. If given two
+ parameters, the point ranges over the entire plane. If given 1
+ or no parameters, returns a point with one parameter which,
+ when varying from 0 to 2*pi, moves the point in a circle of
+ radius 1 about p1 of the Plane.
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Ray
+ >>> from sympy.abc import u, v, t, r
+ >>> p = Plane((1, 1, 1), normal_vector=(1, 0, 0))
+ >>> p.arbitrary_point(u, v)
+ Point3D(1, u + 1, v + 1)
+ >>> p.arbitrary_point(t)
+ Point3D(1, cos(t) + 1, sin(t) + 1)
+
+ While arbitrary values of u and v can move the point anywhere in
+ the plane, the single-parameter point can be used to construct a
+ ray whose arbitrary point can be located at angle t and radius
+ r from p.p1:
+
+ >>> Ray(p.p1, _).arbitrary_point(r)
+ Point3D(1, r*cos(t) + 1, r*sin(t) + 1)
+
+ Returns
+ =======
+
+ Point3D
+
+ """
+ circle = v is None
+ if circle:
+ u = _symbol(u or 't', real=True)
+ else:
+ u = _symbol(u or 'u', real=True)
+ v = _symbol(v or 'v', real=True)
+ x, y, z = self.normal_vector
+ a, b, c = self.p1.args
+ # x1, y1, z1 is a nonzero vector parallel to the plane
+ if x.is_zero and y.is_zero:
+ x1, y1, z1 = S.One, S.Zero, S.Zero
+ else:
+ x1, y1, z1 = -y, x, S.Zero
+ # x2, y2, z2 is also parallel to the plane, and orthogonal to x1, y1, z1
+ x2, y2, z2 = tuple(Matrix((x, y, z)).cross(Matrix((x1, y1, z1))))
+ if circle:
+ x1, y1, z1 = (w/sqrt(x1**2 + y1**2 + z1**2) for w in (x1, y1, z1))
+ x2, y2, z2 = (w/sqrt(x2**2 + y2**2 + z2**2) for w in (x2, y2, z2))
+ p = Point3D(a + x1*cos(u) + x2*sin(u), \
+ b + y1*cos(u) + y2*sin(u), \
+ c + z1*cos(u) + z2*sin(u))
+ else:
+ p = Point3D(a + x1*u + x2*v, b + y1*u + y2*v, c + z1*u + z2*v)
+ return p
+
+
+ @staticmethod
+ def are_concurrent(*planes):
+ """Is a sequence of Planes concurrent?
+
+ Two or more Planes are concurrent if their intersections
+ are a common line.
+
+ Parameters
+ ==========
+
+ planes: list
+
+ Returns
+ =======
+
+ Boolean
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a = Plane(Point3D(5, 0, 0), normal_vector=(1, -1, 1))
+ >>> b = Plane(Point3D(0, -2, 0), normal_vector=(3, 1, 1))
+ >>> c = Plane(Point3D(0, -1, 0), normal_vector=(5, -1, 9))
+ >>> Plane.are_concurrent(a, b)
+ True
+ >>> Plane.are_concurrent(a, b, c)
+ False
+
+ """
+ planes = list(uniq(planes))
+ for i in planes:
+ if not isinstance(i, Plane):
+ raise ValueError('All objects should be Planes but got %s' % i.func)
+ if len(planes) < 2:
+ return False
+ planes = list(planes)
+ first = planes.pop(0)
+ sol = first.intersection(planes[0])
+ if sol == []:
+ return False
+ else:
+ line = sol[0]
+ for i in planes[1:]:
+ l = first.intersection(i)
+ if not l or l[0] not in line:
+ return False
+ return True
+
+
+ def distance(self, o):
+ """Distance between the plane and another geometric entity.
+
+ Parameters
+ ==========
+
+ Point3D, LinearEntity3D, Plane.
+
+ Returns
+ =======
+
+ distance
+
+ Notes
+ =====
+
+ This method accepts only 3D entities as it's parameter, but if you want
+ to calculate the distance between a 2D entity and a plane you should
+ first convert to a 3D entity by projecting onto a desired plane and
+ then proceed to calculate the distance.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D, Plane
+ >>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 1, 1))
+ >>> b = Point3D(1, 2, 3)
+ >>> a.distance(b)
+ sqrt(3)
+ >>> c = Line3D(Point3D(2, 3, 1), Point3D(1, 2, 2))
+ >>> a.distance(c)
+ 0
+
+ """
+ if self.intersection(o) != []:
+ return S.Zero
+
+ if isinstance(o, (Segment3D, Ray3D)):
+ a, b = o.p1, o.p2
+ pi, = self.intersection(Line3D(a, b))
+ if pi in o:
+ return self.distance(pi)
+ elif a in Segment3D(pi, b):
+ return self.distance(a)
+ else:
+ assert isinstance(o, Segment3D) is True
+ return self.distance(b)
+
+ # following code handles `Point3D`, `LinearEntity3D`, `Plane`
+ a = o if isinstance(o, Point3D) else o.p1
+ n = Point3D(self.normal_vector).unit
+ d = (a - self.p1).dot(n)
+ return abs(d)
+
+
+ def equals(self, o):
+ """
+ Returns True if self and o are the same mathematical entities.
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a = Plane(Point3D(1, 2, 3), normal_vector=(1, 1, 1))
+ >>> b = Plane(Point3D(1, 2, 3), normal_vector=(2, 2, 2))
+ >>> c = Plane(Point3D(1, 2, 3), normal_vector=(-1, 4, 6))
+ >>> a.equals(a)
+ True
+ >>> a.equals(b)
+ True
+ >>> a.equals(c)
+ False
+ """
+ if isinstance(o, Plane):
+ a = self.equation()
+ b = o.equation()
+ return cancel(a/b).is_constant()
+ else:
+ return False
+
+
+ def equation(self, x=None, y=None, z=None):
+ """The equation of the Plane.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Plane
+ >>> a = Plane(Point3D(1, 1, 2), Point3D(2, 4, 7), Point3D(3, 5, 1))
+ >>> a.equation()
+ -23*x + 11*y - 2*z + 16
+ >>> a = Plane(Point3D(1, 4, 2), normal_vector=(6, 6, 6))
+ >>> a.equation()
+ 6*x + 6*y + 6*z - 42
+
+ """
+ x, y, z = [i if i else Symbol(j, real=True) for i, j in zip((x, y, z), 'xyz')]
+ a = Point3D(x, y, z)
+ b = self.p1.direction_ratio(a)
+ c = self.normal_vector
+ return (sum(i*j for i, j in zip(b, c)))
+
+
+ def intersection(self, o):
+ """ The intersection with other geometrical entity.
+
+ Parameters
+ ==========
+
+ Point, Point3D, LinearEntity, LinearEntity3D, Plane
+
+ Returns
+ =======
+
+ List
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D, Plane
+ >>> a = Plane(Point3D(1, 2, 3), normal_vector=(1, 1, 1))
+ >>> b = Point3D(1, 2, 3)
+ >>> a.intersection(b)
+ [Point3D(1, 2, 3)]
+ >>> c = Line3D(Point3D(1, 4, 7), Point3D(2, 2, 2))
+ >>> a.intersection(c)
+ [Point3D(2, 2, 2)]
+ >>> d = Plane(Point3D(6, 0, 0), normal_vector=(2, -5, 3))
+ >>> e = Plane(Point3D(2, 0, 0), normal_vector=(3, 4, -3))
+ >>> d.intersection(e)
+ [Line3D(Point3D(78/23, -24/23, 0), Point3D(147/23, 321/23, 23))]
+
+ """
+ if not isinstance(o, GeometryEntity):
+ o = Point(o, dim=3)
+ if isinstance(o, Point):
+ if o in self:
+ return [o]
+ else:
+ return []
+ if isinstance(o, (LinearEntity, LinearEntity3D)):
+ # recast to 3D
+ p1, p2 = o.p1, o.p2
+ if isinstance(o, Segment):
+ o = Segment3D(p1, p2)
+ elif isinstance(o, Ray):
+ o = Ray3D(p1, p2)
+ elif isinstance(o, Line):
+ o = Line3D(p1, p2)
+ else:
+ raise ValueError('unhandled linear entity: %s' % o.func)
+ if o in self:
+ return [o]
+ else:
+ a = Point3D(o.arbitrary_point(t))
+ p1, n = self.p1, Point3D(self.normal_vector)
+
+ # TODO: Replace solve with solveset, when this line is tested
+ c = solve((a - p1).dot(n), t)
+ if not c:
+ return []
+ else:
+ c = [i for i in c if i.is_real is not False]
+ if len(c) > 1:
+ c = [i for i in c if i.is_real]
+ if len(c) != 1:
+ raise Undecidable("not sure which point is real")
+ p = a.subs(t, c[0])
+ if p not in o:
+ return [] # e.g. a segment might not intersect a plane
+ return [p]
+ if isinstance(o, Plane):
+ if self.equals(o):
+ return [self]
+ if self.is_parallel(o):
+ return []
+ else:
+ x, y, z = map(Dummy, 'xyz')
+ a, b = Matrix([self.normal_vector]), Matrix([o.normal_vector])
+ c = list(a.cross(b))
+ d = self.equation(x, y, z)
+ e = o.equation(x, y, z)
+ result = list(linsolve([d, e], x, y, z))[0]
+ for i in (x, y, z): result = result.subs(i, 0)
+ return [Line3D(Point3D(result), direction_ratio=c)]
+
+
+ def is_coplanar(self, o):
+ """ Returns True if `o` is coplanar with self, else False.
+
+ Examples
+ ========
+
+ >>> from sympy import Plane
+ >>> o = (0, 0, 0)
+ >>> p = Plane(o, (1, 1, 1))
+ >>> p2 = Plane(o, (2, 2, 2))
+ >>> p == p2
+ False
+ >>> p.is_coplanar(p2)
+ True
+ """
+ if isinstance(o, Plane):
+ return not cancel(self.equation(x, y, z)/o.equation(x, y, z)).has(x, y, z)
+ if isinstance(o, Point3D):
+ return o in self
+ elif isinstance(o, LinearEntity3D):
+ return all(i in self for i in self)
+ elif isinstance(o, GeometryEntity): # XXX should only be handling 2D objects now
+ return all(i == 0 for i in self.normal_vector[:2])
+
+
+ def is_parallel(self, l):
+ """Is the given geometric entity parallel to the plane?
+
+ Parameters
+ ==========
+
+ LinearEntity3D or Plane
+
+ Returns
+ =======
+
+ Boolean
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
+ >>> b = Plane(Point3D(3,1,3), normal_vector=(4, 8, 12))
+ >>> a.is_parallel(b)
+ True
+
+ """
+ if isinstance(l, LinearEntity3D):
+ a = l.direction_ratio
+ b = self.normal_vector
+ c = sum([i*j for i, j in zip(a, b)])
+ if c == 0:
+ return True
+ else:
+ return False
+ elif isinstance(l, Plane):
+ a = Matrix(l.normal_vector)
+ b = Matrix(self.normal_vector)
+ if a.cross(b).is_zero_matrix:
+ return True
+ else:
+ return False
+
+
+ def is_perpendicular(self, l):
+ """Is the given geometric entity perpendicualar to the given plane?
+
+ Parameters
+ ==========
+
+ LinearEntity3D or Plane
+
+ Returns
+ =======
+
+ Boolean
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
+ >>> b = Plane(Point3D(2, 2, 2), normal_vector=(-1, 2, -1))
+ >>> a.is_perpendicular(b)
+ True
+
+ """
+ if isinstance(l, LinearEntity3D):
+ a = Matrix(l.direction_ratio)
+ b = Matrix(self.normal_vector)
+ if a.cross(b).is_zero_matrix:
+ return True
+ else:
+ return False
+ elif isinstance(l, Plane):
+ a = Matrix(l.normal_vector)
+ b = Matrix(self.normal_vector)
+ if a.dot(b) == 0:
+ return True
+ else:
+ return False
+ else:
+ return False
+
+ @property
+ def normal_vector(self):
+ """Normal vector of the given plane.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Plane
+ >>> a = Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
+ >>> a.normal_vector
+ (-1, 2, -1)
+ >>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 4, 7))
+ >>> a.normal_vector
+ (1, 4, 7)
+
+ """
+ return self.args[1]
+
+ @property
+ def p1(self):
+ """The only defining point of the plane. Others can be obtained from the
+ arbitrary_point method.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point3D
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Plane
+ >>> a = Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
+ >>> a.p1
+ Point3D(1, 1, 1)
+
+ """
+ return self.args[0]
+
+ def parallel_plane(self, pt):
+ """
+ Plane parallel to the given plane and passing through the point pt.
+
+ Parameters
+ ==========
+
+ pt: Point3D
+
+ Returns
+ =======
+
+ Plane
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a = Plane(Point3D(1, 4, 6), normal_vector=(2, 4, 6))
+ >>> a.parallel_plane(Point3D(2, 3, 5))
+ Plane(Point3D(2, 3, 5), (2, 4, 6))
+
+ """
+ a = self.normal_vector
+ return Plane(pt, normal_vector=a)
+
+ def perpendicular_line(self, pt):
+ """A line perpendicular to the given plane.
+
+ Parameters
+ ==========
+
+ pt: Point3D
+
+ Returns
+ =======
+
+ Line3D
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
+ >>> a.perpendicular_line(Point3D(9, 8, 7))
+ Line3D(Point3D(9, 8, 7), Point3D(11, 12, 13))
+
+ """
+ a = self.normal_vector
+ return Line3D(pt, direction_ratio=a)
+
+ def perpendicular_plane(self, *pts):
+ """
+ Return a perpendicular passing through the given points. If the
+ direction ratio between the points is the same as the Plane's normal
+ vector then, to select from the infinite number of possible planes,
+ a third point will be chosen on the z-axis (or the y-axis
+ if the normal vector is already parallel to the z-axis). If less than
+ two points are given they will be supplied as follows: if no point is
+ given then pt1 will be self.p1; if a second point is not given it will
+ be a point through pt1 on a line parallel to the z-axis (if the normal
+ is not already the z-axis, otherwise on the line parallel to the
+ y-axis).
+
+ Parameters
+ ==========
+
+ pts: 0, 1 or 2 Point3D
+
+ Returns
+ =======
+
+ Plane
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a, b = Point3D(0, 0, 0), Point3D(0, 1, 0)
+ >>> Z = (0, 0, 1)
+ >>> p = Plane(a, normal_vector=Z)
+ >>> p.perpendicular_plane(a, b)
+ Plane(Point3D(0, 0, 0), (1, 0, 0))
+ """
+ if len(pts) > 2:
+ raise ValueError('No more than 2 pts should be provided.')
+
+ pts = list(pts)
+ if len(pts) == 0:
+ pts.append(self.p1)
+ if len(pts) == 1:
+ x, y, z = self.normal_vector
+ if x == y == 0:
+ dir = (0, 1, 0)
+ else:
+ dir = (0, 0, 1)
+ pts.append(pts[0] + Point3D(*dir))
+
+ p1, p2 = [Point(i, dim=3) for i in pts]
+ l = Line3D(p1, p2)
+ n = Line3D(p1, direction_ratio=self.normal_vector)
+ if l in n: # XXX should an error be raised instead?
+ # there are infinitely many perpendicular planes;
+ x, y, z = self.normal_vector
+ if x == y == 0:
+ # the z axis is the normal so pick a pt on the y-axis
+ p3 = Point3D(0, 1, 0) # case 1
+ else:
+ # else pick a pt on the z axis
+ p3 = Point3D(0, 0, 1) # case 2
+ # in case that point is already given, move it a bit
+ if p3 in l:
+ p3 *= 2 # case 3
+ else:
+ p3 = p1 + Point3D(*self.normal_vector) # case 4
+ return Plane(p1, p2, p3)
+
+ def projection_line(self, line):
+ """Project the given line onto the plane through the normal plane
+ containing the line.
+
+ Parameters
+ ==========
+
+ LinearEntity or LinearEntity3D
+
+ Returns
+ =======
+
+ Point3D, Line3D, Ray3D or Segment3D
+
+ Notes
+ =====
+
+ For the interaction between 2D and 3D lines(segments, rays), you should
+ convert the line to 3D by using this method. For example for finding the
+ intersection between a 2D and a 3D line, convert the 2D line to a 3D line
+ by projecting it on a required plane and then proceed to find the
+ intersection between those lines.
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Line, Line3D, Point3D
+ >>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 1, 1))
+ >>> b = Line(Point3D(1, 1), Point3D(2, 2))
+ >>> a.projection_line(b)
+ Line3D(Point3D(4/3, 4/3, 1/3), Point3D(5/3, 5/3, -1/3))
+ >>> c = Line3D(Point3D(1, 1, 1), Point3D(2, 2, 2))
+ >>> a.projection_line(c)
+ Point3D(1, 1, 1)
+
+ """
+ if not isinstance(line, (LinearEntity, LinearEntity3D)):
+ raise NotImplementedError('Enter a linear entity only')
+ a, b = self.projection(line.p1), self.projection(line.p2)
+ if a == b:
+ # projection does not imply intersection so for
+ # this case (line parallel to plane's normal) we
+ # return the projection point
+ return a
+ if isinstance(line, (Line, Line3D)):
+ return Line3D(a, b)
+ if isinstance(line, (Ray, Ray3D)):
+ return Ray3D(a, b)
+ if isinstance(line, (Segment, Segment3D)):
+ return Segment3D(a, b)
+
+ def projection(self, pt):
+ """Project the given point onto the plane along the plane normal.
+
+ Parameters
+ ==========
+
+ Point or Point3D
+
+ Returns
+ =======
+
+ Point3D
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> A = Plane(Point3D(1, 1, 2), normal_vector=(1, 1, 1))
+
+ The projection is along the normal vector direction, not the z
+ axis, so (1, 1) does not project to (1, 1, 2) on the plane A:
+
+ >>> b = Point3D(1, 1)
+ >>> A.projection(b)
+ Point3D(5/3, 5/3, 2/3)
+ >>> _ in A
+ True
+
+ But the point (1, 1, 2) projects to (1, 1) on the XY-plane:
+
+ >>> XY = Plane((0, 0, 0), (0, 0, 1))
+ >>> XY.projection((1, 1, 2))
+ Point3D(1, 1, 0)
+ """
+ rv = Point(pt, dim=3)
+ if rv in self:
+ return rv
+ return self.intersection(Line3D(rv, rv + Point3D(self.normal_vector)))[0]
+
+ def random_point(self, seed=None):
+ """ Returns a random point on the Plane.
+
+ Returns
+ =======
+
+ Point3D
+
+ Examples
+ ========
+
+ >>> from sympy import Plane
+ >>> p = Plane((1, 0, 0), normal_vector=(0, 1, 0))
+ >>> r = p.random_point(seed=42) # seed value is optional
+ >>> r.n(3)
+ Point3D(2.29, 0, -1.35)
+
+ The random point can be moved to lie on the circle of radius
+ 1 centered on p1:
+
+ >>> c = p.p1 + (r - p.p1).unit
+ >>> c.distance(p.p1).equals(1)
+ True
+ """
+ if seed is not None:
+ rng = random.Random(seed)
+ else:
+ rng = random
+ params = {
+ x: 2*Rational(rng.gauss(0, 1)) - 1,
+ y: 2*Rational(rng.gauss(0, 1)) - 1}
+ return self.arbitrary_point(x, y).subs(params)
+
+ def parameter_value(self, other, u, v=None):
+ """Return the parameter(s) corresponding to the given point.
+
+ Examples
+ ========
+
+ >>> from sympy import pi, Plane
+ >>> from sympy.abc import t, u, v
+ >>> p = Plane((2, 0, 0), (0, 0, 1), (0, 1, 0))
+
+ By default, the parameter value returned defines a point
+ that is a distance of 1 from the Plane's p1 value and
+ in line with the given point:
+
+ >>> on_circle = p.arbitrary_point(t).subs(t, pi/4)
+ >>> on_circle.distance(p.p1)
+ 1
+ >>> p.parameter_value(on_circle, t)
+ {t: pi/4}
+
+ Moving the point twice as far from p1 does not change
+ the parameter value:
+
+ >>> off_circle = p.p1 + (on_circle - p.p1)*2
+ >>> off_circle.distance(p.p1)
+ 2
+ >>> p.parameter_value(off_circle, t)
+ {t: pi/4}
+
+ If the 2-value parameter is desired, supply the two
+ parameter symbols and a replacement dictionary will
+ be returned:
+
+ >>> p.parameter_value(on_circle, u, v)
+ {u: sqrt(10)/10, v: sqrt(10)/30}
+ >>> p.parameter_value(off_circle, u, v)
+ {u: sqrt(10)/5, v: sqrt(10)/15}
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if not isinstance(other, Point):
+ raise ValueError("other must be a point")
+ if other == self.p1:
+ return other
+ if isinstance(u, Symbol) and v is None:
+ delta = self.arbitrary_point(u) - self.p1
+ eq = delta - (other - self.p1).unit
+ sol = solve(eq, u, dict=True)
+ elif isinstance(u, Symbol) and isinstance(v, Symbol):
+ pt = self.arbitrary_point(u, v)
+ sol = solve(pt - other, (u, v), dict=True)
+ else:
+ raise ValueError('expecting 1 or 2 symbols')
+ if not sol:
+ raise ValueError("Given point is not on %s" % func_name(self))
+ return sol[0] # {t: tval} or {u: uval, v: vval}
+
+ @property
+ def ambient_dimension(self):
+ return self.p1.ambient_dimension
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/point.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/point.py
new file mode 100644
index 0000000000000000000000000000000000000000..81ca7ce61a08d139d2a0d13e545ce008ba9c4298
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/point.py
@@ -0,0 +1,1378 @@
+"""Geometrical Points.
+
+Contains
+========
+Point
+Point2D
+Point3D
+
+When methods of Point require 1 or more points as arguments, they
+can be passed as a sequence of coordinates or Points:
+
+>>> from sympy import Point
+>>> Point(1, 1).is_collinear((2, 2), (3, 4))
+False
+>>> Point(1, 1).is_collinear(Point(2, 2), Point(3, 4))
+False
+
+"""
+
+import warnings
+
+from sympy.core import S, sympify, Expr
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.numbers import Float
+from sympy.core.parameters import global_parameters
+from sympy.simplify import nsimplify, simplify
+from sympy.geometry.exceptions import GeometryError
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.complexes import im
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.matrices import Matrix
+from sympy.matrices.expressions import Transpose
+from sympy.utilities.iterables import uniq, is_sequence
+from sympy.utilities.misc import filldedent, func_name, Undecidable
+
+from .entity import GeometryEntity
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+class Point(GeometryEntity):
+ """A point in a n-dimensional Euclidean space.
+
+ Parameters
+ ==========
+
+ coords : sequence of n-coordinate values. In the special
+ case where n=2 or 3, a Point2D or Point3D will be created
+ as appropriate.
+ evaluate : if `True` (default), all floats are turn into
+ exact types.
+ dim : number of coordinates the point should have. If coordinates
+ are unspecified, they are padded with zeros.
+ on_morph : indicates what should happen when the number of
+ coordinates of a point need to be changed by adding or
+ removing zeros. Possible values are `'warn'`, `'error'`, or
+ `ignore` (default). No warning or error is given when `*args`
+ is empty and `dim` is given. An error is always raised when
+ trying to remove nonzero coordinates.
+
+
+ Attributes
+ ==========
+
+ length
+ origin: A `Point` representing the origin of the
+ appropriately-dimensioned space.
+
+ Raises
+ ======
+
+ TypeError : When instantiating with anything but a Point or sequence
+ ValueError : when instantiating with a sequence with length < 2 or
+ when trying to reduce dimensions if keyword `on_morph='error'` is
+ set.
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment : Connects two Points
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> from sympy.abc import x
+ >>> Point(1, 2, 3)
+ Point3D(1, 2, 3)
+ >>> Point([1, 2])
+ Point2D(1, 2)
+ >>> Point(0, x)
+ Point2D(0, x)
+ >>> Point(dim=4)
+ Point(0, 0, 0, 0)
+
+ Floats are automatically converted to Rational unless the
+ evaluate flag is False:
+
+ >>> Point(0.5, 0.25)
+ Point2D(1/2, 1/4)
+ >>> Point(0.5, 0.25, evaluate=False)
+ Point2D(0.5, 0.25)
+
+ """
+
+ is_Point = True
+
+ def __new__(cls, *args, **kwargs):
+ evaluate = kwargs.get('evaluate', global_parameters.evaluate)
+ on_morph = kwargs.get('on_morph', 'ignore')
+
+ # unpack into coords
+ coords = args[0] if len(args) == 1 else args
+
+ # check args and handle quickly handle Point instances
+ if isinstance(coords, Point):
+ # even if we're mutating the dimension of a point, we
+ # don't reevaluate its coordinates
+ evaluate = False
+ if len(coords) == kwargs.get('dim', len(coords)):
+ return coords
+
+ if not is_sequence(coords):
+ raise TypeError(filldedent('''
+ Expecting sequence of coordinates, not `{}`'''
+ .format(func_name(coords))))
+ # A point where only `dim` is specified is initialized
+ # to zeros.
+ if len(coords) == 0 and kwargs.get('dim', None):
+ coords = (S.Zero,)*kwargs.get('dim')
+
+ coords = Tuple(*coords)
+ dim = kwargs.get('dim', len(coords))
+
+ if len(coords) < 2:
+ raise ValueError(filldedent('''
+ Point requires 2 or more coordinates or
+ keyword `dim` > 1.'''))
+ if len(coords) != dim:
+ message = ("Dimension of {} needs to be changed "
+ "from {} to {}.").format(coords, len(coords), dim)
+ if on_morph == 'ignore':
+ pass
+ elif on_morph == "error":
+ raise ValueError(message)
+ elif on_morph == 'warn':
+ warnings.warn(message, stacklevel=2)
+ else:
+ raise ValueError(filldedent('''
+ on_morph value should be 'error',
+ 'warn' or 'ignore'.'''))
+ if any(coords[dim:]):
+ raise ValueError('Nonzero coordinates cannot be removed.')
+ if any(a.is_number and im(a).is_zero is False for a in coords):
+ raise ValueError('Imaginary coordinates are not permitted.')
+ if not all(isinstance(a, Expr) for a in coords):
+ raise TypeError('Coordinates must be valid SymPy expressions.')
+
+ # pad with zeros appropriately
+ coords = coords[:dim] + (S.Zero,)*(dim - len(coords))
+
+ # Turn any Floats into rationals and simplify
+ # any expressions before we instantiate
+ if evaluate:
+ coords = coords.xreplace({
+ f: simplify(nsimplify(f, rational=True))
+ for f in coords.atoms(Float)})
+
+ # return 2D or 3D instances
+ if len(coords) == 2:
+ kwargs['_nocheck'] = True
+ return Point2D(*coords, **kwargs)
+ elif len(coords) == 3:
+ kwargs['_nocheck'] = True
+ return Point3D(*coords, **kwargs)
+
+ # the general Point
+ return GeometryEntity.__new__(cls, *coords)
+
+ def __abs__(self):
+ """Returns the distance between this point and the origin."""
+ origin = Point([0]*len(self))
+ return Point.distance(origin, self)
+
+ def __add__(self, other):
+ """Add other to self by incrementing self's coordinates by
+ those of other.
+
+ Notes
+ =====
+
+ >>> from sympy import Point
+
+ When sequences of coordinates are passed to Point methods, they
+ are converted to a Point internally. This __add__ method does
+ not do that so if floating point values are used, a floating
+ point result (in terms of SymPy Floats) will be returned.
+
+ >>> Point(1, 2) + (.1, .2)
+ Point2D(1.1, 2.2)
+
+ If this is not desired, the `translate` method can be used or
+ another Point can be added:
+
+ >>> Point(1, 2).translate(.1, .2)
+ Point2D(11/10, 11/5)
+ >>> Point(1, 2) + Point(.1, .2)
+ Point2D(11/10, 11/5)
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.translate
+
+ """
+ try:
+ s, o = Point._normalize_dimension(self, Point(other, evaluate=False))
+ except TypeError:
+ raise GeometryError("Don't know how to add {} and a Point object".format(other))
+
+ coords = [simplify(a + b) for a, b in zip(s, o)]
+ return Point(coords, evaluate=False)
+
+ def __contains__(self, item):
+ return item in self.args
+
+ def __truediv__(self, divisor):
+ """Divide point's coordinates by a factor."""
+ divisor = sympify(divisor)
+ coords = [simplify(x/divisor) for x in self.args]
+ return Point(coords, evaluate=False)
+
+ def __eq__(self, other):
+ if not isinstance(other, Point) or len(self.args) != len(other.args):
+ return False
+ return self.args == other.args
+
+ def __getitem__(self, key):
+ return self.args[key]
+
+ def __hash__(self):
+ return hash(self.args)
+
+ def __iter__(self):
+ return self.args.__iter__()
+
+ def __len__(self):
+ return len(self.args)
+
+ def __mul__(self, factor):
+ """Multiply point's coordinates by a factor.
+
+ Notes
+ =====
+
+ >>> from sympy import Point
+
+ When multiplying a Point by a floating point number,
+ the coordinates of the Point will be changed to Floats:
+
+ >>> Point(1, 2)*0.1
+ Point2D(0.1, 0.2)
+
+ If this is not desired, the `scale` method can be used or
+ else only multiply or divide by integers:
+
+ >>> Point(1, 2).scale(1.1, 1.1)
+ Point2D(11/10, 11/5)
+ >>> Point(1, 2)*11/10
+ Point2D(11/10, 11/5)
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.scale
+ """
+ factor = sympify(factor)
+ coords = [simplify(x*factor) for x in self.args]
+ return Point(coords, evaluate=False)
+
+ def __rmul__(self, factor):
+ """Multiply a factor by point's coordinates."""
+ return self.__mul__(factor)
+
+ def __neg__(self):
+ """Negate the point."""
+ coords = [-x for x in self.args]
+ return Point(coords, evaluate=False)
+
+ def __sub__(self, other):
+ """Subtract two points, or subtract a factor from this point's
+ coordinates."""
+ return self + [-x for x in other]
+
+ @classmethod
+ def _normalize_dimension(cls, *points, **kwargs):
+ """Ensure that points have the same dimension.
+ By default `on_morph='warn'` is passed to the
+ `Point` constructor."""
+ # if we have a built-in ambient dimension, use it
+ dim = getattr(cls, '_ambient_dimension', None)
+ # override if we specified it
+ dim = kwargs.get('dim', dim)
+ # if no dim was given, use the highest dimensional point
+ if dim is None:
+ dim = max(i.ambient_dimension for i in points)
+ if all(i.ambient_dimension == dim for i in points):
+ return list(points)
+ kwargs['dim'] = dim
+ kwargs['on_morph'] = kwargs.get('on_morph', 'warn')
+ return [Point(i, **kwargs) for i in points]
+
+ @staticmethod
+ def affine_rank(*args):
+ """The affine rank of a set of points is the dimension
+ of the smallest affine space containing all the points.
+ For example, if the points lie on a line (and are not all
+ the same) their affine rank is 1. If the points lie on a plane
+ but not a line, their affine rank is 2. By convention, the empty
+ set has affine rank -1."""
+
+ if len(args) == 0:
+ return -1
+ # make sure we're genuinely points
+ # and translate every point to the origin
+ points = Point._normalize_dimension(*[Point(i) for i in args])
+ origin = points[0]
+ points = [i - origin for i in points[1:]]
+
+ m = Matrix([i.args for i in points])
+ # XXX fragile -- what is a better way?
+ return m.rank(iszerofunc = lambda x:
+ abs(x.n(2)) < 1e-12 if x.is_number else x.is_zero)
+
+ @property
+ def ambient_dimension(self):
+ """Number of components this point has."""
+ return getattr(self, '_ambient_dimension', len(self))
+
+ @classmethod
+ def are_coplanar(cls, *points):
+ """Return True if there exists a plane in which all the points
+ lie. A trivial True value is returned if `len(points) < 3` or
+ all Points are 2-dimensional.
+
+ Parameters
+ ==========
+
+ A set of points
+
+ Raises
+ ======
+
+ ValueError : if less than 3 unique points are given
+
+ Returns
+ =======
+
+ boolean
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p1 = Point3D(1, 2, 2)
+ >>> p2 = Point3D(2, 7, 2)
+ >>> p3 = Point3D(0, 0, 2)
+ >>> p4 = Point3D(1, 1, 2)
+ >>> Point3D.are_coplanar(p1, p2, p3, p4)
+ True
+ >>> p5 = Point3D(0, 1, 3)
+ >>> Point3D.are_coplanar(p1, p2, p3, p5)
+ False
+
+ """
+ if len(points) <= 1:
+ return True
+
+ points = cls._normalize_dimension(*[Point(i) for i in points])
+ # quick exit if we are in 2D
+ if points[0].ambient_dimension == 2:
+ return True
+ points = list(uniq(points))
+ return Point.affine_rank(*points) <= 2
+
+ def distance(self, other):
+ """The Euclidean distance between self and another GeometricEntity.
+
+ Returns
+ =======
+
+ distance : number or symbolic expression.
+
+ Raises
+ ======
+
+ TypeError : if other is not recognized as a GeometricEntity or is a
+ GeometricEntity for which distance is not defined.
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment.length
+ sympy.geometry.point.Point.taxicab_distance
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(1, 1), Point(4, 5)
+ >>> l = Line((3, 1), (2, 2))
+ >>> p1.distance(p2)
+ 5
+ >>> p1.distance(l)
+ sqrt(2)
+
+ The computed distance may be symbolic, too:
+
+ >>> from sympy.abc import x, y
+ >>> p3 = Point(x, y)
+ >>> p3.distance((0, 0))
+ sqrt(x**2 + y**2)
+
+ """
+ if not isinstance(other, GeometryEntity):
+ try:
+ other = Point(other, dim=self.ambient_dimension)
+ except TypeError:
+ raise TypeError("not recognized as a GeometricEntity: %s" % type(other))
+ if isinstance(other, Point):
+ s, p = Point._normalize_dimension(self, Point(other))
+ return sqrt(Add(*((a - b)**2 for a, b in zip(s, p))))
+ distance = getattr(other, 'distance', None)
+ if distance is None:
+ raise TypeError("distance between Point and %s is not defined" % type(other))
+ return distance(self)
+
+ def dot(self, p):
+ """Return dot product of self with another Point."""
+ if not is_sequence(p):
+ p = Point(p) # raise the error via Point
+ return Add(*(a*b for a, b in zip(self, p)))
+
+ def equals(self, other):
+ """Returns whether the coordinates of self and other agree."""
+ # a point is equal to another point if all its components are equal
+ if not isinstance(other, Point) or len(self) != len(other):
+ return False
+ return all(a.equals(b) for a, b in zip(self, other))
+
+ def _eval_evalf(self, prec=15, **options):
+ """Evaluate the coordinates of the point.
+
+ This method will, where possible, create and return a new Point
+ where the coordinates are evaluated as floating point numbers to
+ the precision indicated (default=15).
+
+ Parameters
+ ==========
+
+ prec : int
+
+ Returns
+ =======
+
+ point : Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Rational
+ >>> p1 = Point(Rational(1, 2), Rational(3, 2))
+ >>> p1
+ Point2D(1/2, 3/2)
+ >>> p1.evalf()
+ Point2D(0.5, 1.5)
+
+ """
+ dps = prec_to_dps(prec)
+ coords = [x.evalf(n=dps, **options) for x in self.args]
+ return Point(*coords, evaluate=False)
+
+ def intersection(self, other):
+ """The intersection between this point and another GeometryEntity.
+
+ Parameters
+ ==========
+
+ other : GeometryEntity or sequence of coordinates
+
+ Returns
+ =======
+
+ intersection : list of Points
+
+ Notes
+ =====
+
+ The return value will either be an empty list if there is no
+ intersection, otherwise it will contain this point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, 0)
+ >>> p1.intersection(p2)
+ []
+ >>> p1.intersection(p3)
+ [Point2D(0, 0)]
+
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other)
+ if isinstance(other, Point):
+ if self == other:
+ return [self]
+ p1, p2 = Point._normalize_dimension(self, other)
+ if p1 == self and p1 == p2:
+ return [self]
+ return []
+ return other.intersection(self)
+
+ def is_collinear(self, *args):
+ """Returns `True` if there exists a line
+ that contains `self` and `points`. Returns `False` otherwise.
+ A trivially True value is returned if no points are given.
+
+ Parameters
+ ==========
+
+ args : sequence of Points
+
+ Returns
+ =======
+
+ is_collinear : boolean
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> from sympy.abc import x
+ >>> p1, p2 = Point(0, 0), Point(1, 1)
+ >>> p3, p4, p5 = Point(2, 2), Point(x, x), Point(1, 2)
+ >>> Point.is_collinear(p1, p2, p3, p4)
+ True
+ >>> Point.is_collinear(p1, p2, p3, p5)
+ False
+
+ """
+ points = (self,) + args
+ points = Point._normalize_dimension(*[Point(i) for i in points])
+ points = list(uniq(points))
+ return Point.affine_rank(*points) <= 1
+
+ def is_concyclic(self, *args):
+ """Do `self` and the given sequence of points lie in a circle?
+
+ Returns True if the set of points are concyclic and
+ False otherwise. A trivial value of True is returned
+ if there are fewer than 2 other points.
+
+ Parameters
+ ==========
+
+ args : sequence of Points
+
+ Returns
+ =======
+
+ is_concyclic : boolean
+
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+
+ Define 4 points that are on the unit circle:
+
+ >>> p1, p2, p3, p4 = Point(1, 0), (0, 1), (-1, 0), (0, -1)
+
+ >>> p1.is_concyclic() == p1.is_concyclic(p2, p3, p4) == True
+ True
+
+ Define a point not on that circle:
+
+ >>> p = Point(1, 1)
+
+ >>> p.is_concyclic(p1, p2, p3)
+ False
+
+ """
+ points = (self,) + args
+ points = Point._normalize_dimension(*[Point(i) for i in points])
+ points = list(uniq(points))
+ if not Point.affine_rank(*points) <= 2:
+ return False
+ origin = points[0]
+ points = [p - origin for p in points]
+ # points are concyclic if they are coplanar and
+ # there is a point c so that ||p_i-c|| == ||p_j-c|| for all
+ # i and j. Rearranging this equation gives us the following
+ # condition: the matrix `mat` must not a pivot in the last
+ # column.
+ mat = Matrix([list(i) + [i.dot(i)] for i in points])
+ rref, pivots = mat.rref()
+ if len(origin) not in pivots:
+ return True
+ return False
+
+ @property
+ def is_nonzero(self):
+ """True if any coordinate is nonzero, False if every coordinate is zero,
+ and None if it cannot be determined."""
+ is_zero = self.is_zero
+ if is_zero is None:
+ return None
+ return not is_zero
+
+ def is_scalar_multiple(self, p):
+ """Returns whether each coordinate of `self` is a scalar
+ multiple of the corresponding coordinate in point p.
+ """
+ s, o = Point._normalize_dimension(self, Point(p))
+ # 2d points happen a lot, so optimize this function call
+ if s.ambient_dimension == 2:
+ (x1, y1), (x2, y2) = s.args, o.args
+ rv = (x1*y2 - x2*y1).equals(0)
+ if rv is None:
+ raise Undecidable(filldedent(
+ '''Cannot determine if %s is a scalar multiple of
+ %s''' % (s, o)))
+
+ # if the vectors p1 and p2 are linearly dependent, then they must
+ # be scalar multiples of each other
+ m = Matrix([s.args, o.args])
+ return m.rank() < 2
+
+ @property
+ def is_zero(self):
+ """True if every coordinate is zero, False if any coordinate is not zero,
+ and None if it cannot be determined."""
+ nonzero = [x.is_nonzero for x in self.args]
+ if any(nonzero):
+ return False
+ if any(x is None for x in nonzero):
+ return None
+ return True
+
+ @property
+ def length(self):
+ """
+ Treating a Point as a Line, this returns 0 for the length of a Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> p = Point(0, 1)
+ >>> p.length
+ 0
+ """
+ return S.Zero
+
+ def midpoint(self, p):
+ """The midpoint between self and point p.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ midpoint : Point
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment.midpoint
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> p1, p2 = Point(1, 1), Point(13, 5)
+ >>> p1.midpoint(p2)
+ Point2D(7, 3)
+
+ """
+ s, p = Point._normalize_dimension(self, Point(p))
+ return Point([simplify((a + b)*S.Half) for a, b in zip(s, p)])
+
+ @property
+ def origin(self):
+ """A point of all zeros of the same ambient dimension
+ as the current point"""
+ return Point([0]*len(self), evaluate=False)
+
+ @property
+ def orthogonal_direction(self):
+ """Returns a non-zero point that is orthogonal to the
+ line containing `self` and the origin.
+
+ Examples
+ ========
+
+ >>> from sympy import Line, Point
+ >>> a = Point(1, 2, 3)
+ >>> a.orthogonal_direction
+ Point3D(-2, 1, 0)
+ >>> b = _
+ >>> Line(b, b.origin).is_perpendicular(Line(a, a.origin))
+ True
+ """
+ dim = self.ambient_dimension
+ # if a coordinate is zero, we can put a 1 there and zeros elsewhere
+ if self[0].is_zero:
+ return Point([1] + (dim - 1)*[0])
+ if self[1].is_zero:
+ return Point([0,1] + (dim - 2)*[0])
+ # if the first two coordinates aren't zero, we can create a non-zero
+ # orthogonal vector by swapping them, negating one, and padding with zeros
+ return Point([-self[1], self[0]] + (dim - 2)*[0])
+
+ @staticmethod
+ def project(a, b):
+ """Project the point `a` onto the line between the origin
+ and point `b` along the normal direction.
+
+ Parameters
+ ==========
+
+ a : Point
+ b : Point
+
+ Returns
+ =======
+
+ p : Point
+
+ See Also
+ ========
+
+ sympy.geometry.line.LinearEntity.projection
+
+ Examples
+ ========
+
+ >>> from sympy import Line, Point
+ >>> a = Point(1, 2)
+ >>> b = Point(2, 5)
+ >>> z = a.origin
+ >>> p = Point.project(a, b)
+ >>> Line(p, a).is_perpendicular(Line(p, b))
+ True
+ >>> Point.is_collinear(z, p, b)
+ True
+ """
+ a, b = Point._normalize_dimension(Point(a), Point(b))
+ if b.is_zero:
+ raise ValueError("Cannot project to the zero vector.")
+ return b*(a.dot(b) / b.dot(b))
+
+ def taxicab_distance(self, p):
+ """The Taxicab Distance from self to point p.
+
+ Returns the sum of the horizontal and vertical distances to point p.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ taxicab_distance : The sum of the horizontal
+ and vertical distances to point p.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.distance
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> p1, p2 = Point(1, 1), Point(4, 5)
+ >>> p1.taxicab_distance(p2)
+ 7
+
+ """
+ s, p = Point._normalize_dimension(self, Point(p))
+ return Add(*(abs(a - b) for a, b in zip(s, p)))
+
+ def canberra_distance(self, p):
+ """The Canberra Distance from self to point p.
+
+ Returns the weighted sum of horizontal and vertical distances to
+ point p.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ canberra_distance : The weighted sum of horizontal and vertical
+ distances to point p. The weight used is the sum of absolute values
+ of the coordinates.
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> p1, p2 = Point(1, 1), Point(3, 3)
+ >>> p1.canberra_distance(p2)
+ 1
+ >>> p1, p2 = Point(0, 0), Point(3, 3)
+ >>> p1.canberra_distance(p2)
+ 2
+
+ Raises
+ ======
+
+ ValueError when both vectors are zero.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.distance
+
+ """
+
+ s, p = Point._normalize_dimension(self, Point(p))
+ if self.is_zero and p.is_zero:
+ raise ValueError("Cannot project to the zero vector.")
+ return Add(*((abs(a - b)/(abs(a) + abs(b))) for a, b in zip(s, p)))
+
+ @property
+ def unit(self):
+ """Return the Point that is in the same direction as `self`
+ and a distance of 1 from the origin"""
+ return self / abs(self)
+
+
+class Point2D(Point):
+ """A point in a 2-dimensional Euclidean space.
+
+ Parameters
+ ==========
+
+ coords
+ A sequence of 2 coordinate values.
+
+ Attributes
+ ==========
+
+ x
+ y
+ length
+
+ Raises
+ ======
+
+ TypeError
+ When trying to add or subtract points with different dimensions.
+ When trying to create a point with more than two dimensions.
+ When `intersection` is called with object other than a Point.
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment : Connects two Points
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D
+ >>> from sympy.abc import x
+ >>> Point2D(1, 2)
+ Point2D(1, 2)
+ >>> Point2D([1, 2])
+ Point2D(1, 2)
+ >>> Point2D(0, x)
+ Point2D(0, x)
+
+ Floats are automatically converted to Rational unless the
+ evaluate flag is False:
+
+ >>> Point2D(0.5, 0.25)
+ Point2D(1/2, 1/4)
+ >>> Point2D(0.5, 0.25, evaluate=False)
+ Point2D(0.5, 0.25)
+
+ """
+
+ _ambient_dimension = 2
+
+ def __new__(cls, *args, _nocheck=False, **kwargs):
+ if not _nocheck:
+ kwargs['dim'] = 2
+ args = Point(*args, **kwargs)
+ return GeometryEntity.__new__(cls, *args)
+
+ def __contains__(self, item):
+ return item == self
+
+ @property
+ def bounds(self):
+ """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+ rectangle for the geometric figure.
+
+ """
+
+ return (self.x, self.y, self.x, self.y)
+
+ def rotate(self, angle, pt=None):
+ """Rotate ``angle`` radians counterclockwise about Point ``pt``.
+
+ See Also
+ ========
+
+ translate, scale
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D, pi
+ >>> t = Point2D(1, 0)
+ >>> t.rotate(pi/2)
+ Point2D(0, 1)
+ >>> t.rotate(pi/2, (2, 0))
+ Point2D(2, -1)
+
+ """
+ c = cos(angle)
+ s = sin(angle)
+
+ rv = self
+ if pt is not None:
+ pt = Point(pt, dim=2)
+ rv -= pt
+ x, y = rv.args
+ rv = Point(c*x - s*y, s*x + c*y)
+ if pt is not None:
+ rv += pt
+ return rv
+
+ def scale(self, x=1, y=1, pt=None):
+ """Scale the coordinates of the Point by multiplying by
+ ``x`` and ``y`` after subtracting ``pt`` -- default is (0, 0) --
+ and then adding ``pt`` back again (i.e. ``pt`` is the point of
+ reference for the scaling).
+
+ See Also
+ ========
+
+ rotate, translate
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D
+ >>> t = Point2D(1, 1)
+ >>> t.scale(2)
+ Point2D(2, 1)
+ >>> t.scale(2, 2)
+ Point2D(2, 2)
+
+ """
+ if pt:
+ pt = Point(pt, dim=2)
+ return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+ return Point(self.x*x, self.y*y)
+
+ def transform(self, matrix):
+ """Return the point after applying the transformation described
+ by the 3x3 Matrix, ``matrix``.
+
+ See Also
+ ========
+ sympy.geometry.point.Point2D.rotate
+ sympy.geometry.point.Point2D.scale
+ sympy.geometry.point.Point2D.translate
+ """
+ if not (matrix.is_Matrix and matrix.shape == (3, 3)):
+ raise ValueError("matrix must be a 3x3 matrix")
+ x, y = self.args
+ return Point(*(Matrix(1, 3, [x, y, 1])*matrix).tolist()[0][:2])
+
+ def translate(self, x=0, y=0):
+ """Shift the Point by adding x and y to the coordinates of the Point.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point2D.rotate, scale
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D
+ >>> t = Point2D(0, 1)
+ >>> t.translate(2)
+ Point2D(2, 1)
+ >>> t.translate(2, 2)
+ Point2D(2, 3)
+ >>> t + Point2D(2, 2)
+ Point2D(2, 3)
+
+ """
+ return Point(self.x + x, self.y + y)
+
+ @property
+ def coordinates(self):
+ """
+ Returns the two coordinates of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D
+ >>> p = Point2D(0, 1)
+ >>> p.coordinates
+ (0, 1)
+ """
+ return self.args
+
+ @property
+ def x(self):
+ """
+ Returns the X coordinate of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D
+ >>> p = Point2D(0, 1)
+ >>> p.x
+ 0
+ """
+ return self.args[0]
+
+ @property
+ def y(self):
+ """
+ Returns the Y coordinate of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D
+ >>> p = Point2D(0, 1)
+ >>> p.y
+ 1
+ """
+ return self.args[1]
+
+class Point3D(Point):
+ """A point in a 3-dimensional Euclidean space.
+
+ Parameters
+ ==========
+
+ coords
+ A sequence of 3 coordinate values.
+
+ Attributes
+ ==========
+
+ x
+ y
+ z
+ length
+
+ Raises
+ ======
+
+ TypeError
+ When trying to add or subtract points with different dimensions.
+ When `intersection` is called with object other than a Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> from sympy.abc import x
+ >>> Point3D(1, 2, 3)
+ Point3D(1, 2, 3)
+ >>> Point3D([1, 2, 3])
+ Point3D(1, 2, 3)
+ >>> Point3D(0, x, 3)
+ Point3D(0, x, 3)
+
+ Floats are automatically converted to Rational unless the
+ evaluate flag is False:
+
+ >>> Point3D(0.5, 0.25, 2)
+ Point3D(1/2, 1/4, 2)
+ >>> Point3D(0.5, 0.25, 3, evaluate=False)
+ Point3D(0.5, 0.25, 3)
+
+ """
+
+ _ambient_dimension = 3
+
+ def __new__(cls, *args, _nocheck=False, **kwargs):
+ if not _nocheck:
+ kwargs['dim'] = 3
+ args = Point(*args, **kwargs)
+ return GeometryEntity.__new__(cls, *args)
+
+ def __contains__(self, item):
+ return item == self
+
+ @staticmethod
+ def are_collinear(*points):
+ """Is a sequence of points collinear?
+
+ Test whether or not a set of points are collinear. Returns True if
+ the set of points are collinear, or False otherwise.
+
+ Parameters
+ ==========
+
+ points : sequence of Point
+
+ Returns
+ =======
+
+ are_collinear : boolean
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line3D
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> from sympy.abc import x
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(1, 1, 1)
+ >>> p3, p4, p5 = Point3D(2, 2, 2), Point3D(x, x, x), Point3D(1, 2, 6)
+ >>> Point3D.are_collinear(p1, p2, p3, p4)
+ True
+ >>> Point3D.are_collinear(p1, p2, p3, p5)
+ False
+ """
+ return Point.is_collinear(*points)
+
+ def direction_cosine(self, point):
+ """
+ Gives the direction cosine between 2 points
+
+ Parameters
+ ==========
+
+ p : Point3D
+
+ Returns
+ =======
+
+ list
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p1 = Point3D(1, 2, 3)
+ >>> p1.direction_cosine(Point3D(2, 3, 5))
+ [sqrt(6)/6, sqrt(6)/6, sqrt(6)/3]
+ """
+ a = self.direction_ratio(point)
+ b = sqrt(Add(*(i**2 for i in a)))
+ return [(point.x - self.x) / b,(point.y - self.y) / b,
+ (point.z - self.z) / b]
+
+ def direction_ratio(self, point):
+ """
+ Gives the direction ratio between 2 points
+
+ Parameters
+ ==========
+
+ p : Point3D
+
+ Returns
+ =======
+
+ list
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p1 = Point3D(1, 2, 3)
+ >>> p1.direction_ratio(Point3D(2, 3, 5))
+ [1, 1, 2]
+ """
+ return [(point.x - self.x),(point.y - self.y),(point.z - self.z)]
+
+ def intersection(self, other):
+ """The intersection between this point and another GeometryEntity.
+
+ Parameters
+ ==========
+
+ other : GeometryEntity or sequence of coordinates
+
+ Returns
+ =======
+
+ intersection : list of Points
+
+ Notes
+ =====
+
+ The return value will either be an empty list if there is no
+ intersection, otherwise it will contain this point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, 0, 0)
+ >>> p1.intersection(p2)
+ []
+ >>> p1.intersection(p3)
+ [Point3D(0, 0, 0)]
+
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=3)
+ if isinstance(other, Point3D):
+ if self == other:
+ return [self]
+ return []
+ return other.intersection(self)
+
+ def scale(self, x=1, y=1, z=1, pt=None):
+ """Scale the coordinates of the Point by multiplying by
+ ``x`` and ``y`` after subtracting ``pt`` -- default is (0, 0) --
+ and then adding ``pt`` back again (i.e. ``pt`` is the point of
+ reference for the scaling).
+
+ See Also
+ ========
+
+ translate
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> t = Point3D(1, 1, 1)
+ >>> t.scale(2)
+ Point3D(2, 1, 1)
+ >>> t.scale(2, 2)
+ Point3D(2, 2, 1)
+
+ """
+ if pt:
+ pt = Point3D(pt)
+ return self.translate(*(-pt).args).scale(x, y, z).translate(*pt.args)
+ return Point3D(self.x*x, self.y*y, self.z*z)
+
+ def transform(self, matrix):
+ """Return the point after applying the transformation described
+ by the 4x4 Matrix, ``matrix``.
+
+ See Also
+ ========
+ sympy.geometry.point.Point3D.scale
+ sympy.geometry.point.Point3D.translate
+ """
+ if not (matrix.is_Matrix and matrix.shape == (4, 4)):
+ raise ValueError("matrix must be a 4x4 matrix")
+ x, y, z = self.args
+ m = Transpose(matrix)
+ return Point3D(*(Matrix(1, 4, [x, y, z, 1])*m).tolist()[0][:3])
+
+ def translate(self, x=0, y=0, z=0):
+ """Shift the Point by adding x and y to the coordinates of the Point.
+
+ See Also
+ ========
+
+ scale
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> t = Point3D(0, 1, 1)
+ >>> t.translate(2)
+ Point3D(2, 1, 1)
+ >>> t.translate(2, 2)
+ Point3D(2, 3, 1)
+ >>> t + Point3D(2, 2, 2)
+ Point3D(2, 3, 3)
+
+ """
+ return Point3D(self.x + x, self.y + y, self.z + z)
+
+ @property
+ def coordinates(self):
+ """
+ Returns the three coordinates of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p = Point3D(0, 1, 2)
+ >>> p.coordinates
+ (0, 1, 2)
+ """
+ return self.args
+
+ @property
+ def x(self):
+ """
+ Returns the X coordinate of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p = Point3D(0, 1, 3)
+ >>> p.x
+ 0
+ """
+ return self.args[0]
+
+ @property
+ def y(self):
+ """
+ Returns the Y coordinate of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p = Point3D(0, 1, 2)
+ >>> p.y
+ 1
+ """
+ return self.args[1]
+
+ @property
+ def z(self):
+ """
+ Returns the Z coordinate of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p = Point3D(0, 1, 1)
+ >>> p.z
+ 1
+ """
+ return self.args[2]
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__init__.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13b071f779af43adbea0b5961f68b6081fdbeec8
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_curve.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_curve.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3711121b528b185e8280e7f48a4bc280a37aa23b
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_curve.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_ellipse.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_ellipse.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bc9f74074c10d87dcdbef468fa94b8269d603181
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_ellipse.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_entity.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_entity.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4ed6b51e0727e9736214f79bcc477f89cc08baa3
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_entity.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_geometrysets.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_geometrysets.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..163dacde4831897fb2abe0fb731400eb04785aff
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_geometrysets.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_line.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_line.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a7e3a2d2f64003b52cf33682485f32e2422413ea
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_line.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_parabola.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_parabola.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a0fec182f38048cb8bc760cdc0034d92591df0b8
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_parabola.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_plane.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_plane.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5cb9a1661d90cef7f249743ecc24a3981fe6879c
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_plane.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_point.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_point.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1cdb1be097a4e1abd2f2475a5da98b5a91daf2de
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_point.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_polygon.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_polygon.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4bfe8a76709659a52060abc762ee025e2d39d4e6
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_polygon.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_util.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_util.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f4c7aa553c3c22e2c8f91e5f2639e86aa760cfb8
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_util.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_curve.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_curve.py
new file mode 100644
index 0000000000000000000000000000000000000000..50aa80273a1d8eb9e414a8d591571f3127352dad
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_curve.py
@@ -0,0 +1,120 @@
+from sympy.core.containers import Tuple
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.hyperbolic import asinh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.geometry import Curve, Line, Point, Ellipse, Ray, Segment, Circle, Polygon, RegularPolygon
+from sympy.testing.pytest import raises, slow
+
+
+def test_curve():
+ x = Symbol('x', real=True)
+ s = Symbol('s')
+ z = Symbol('z')
+
+ # this curve is independent of the indicated parameter
+ c = Curve([2*s, s**2], (z, 0, 2))
+
+ assert c.parameter == z
+ assert c.functions == (2*s, s**2)
+ assert c.arbitrary_point() == Point(2*s, s**2)
+ assert c.arbitrary_point(z) == Point(2*s, s**2)
+
+ # this is how it is normally used
+ c = Curve([2*s, s**2], (s, 0, 2))
+
+ assert c.parameter == s
+ assert c.functions == (2*s, s**2)
+ t = Symbol('t')
+ # the t returned as assumptions
+ assert c.arbitrary_point() != Point(2*t, t**2)
+ t = Symbol('t', real=True)
+ # now t has the same assumptions so the test passes
+ assert c.arbitrary_point() == Point(2*t, t**2)
+ assert c.arbitrary_point(z) == Point(2*z, z**2)
+ assert c.arbitrary_point(c.parameter) == Point(2*s, s**2)
+ assert c.arbitrary_point(None) == Point(2*s, s**2)
+ assert c.plot_interval() == [t, 0, 2]
+ assert c.plot_interval(z) == [z, 0, 2]
+
+ assert Curve([x, x], (x, 0, 1)).rotate(pi/2) == Curve([-x, x], (x, 0, 1))
+ assert Curve([x, x], (x, 0, 1)).rotate(pi/2, (1, 2)).scale(2, 3).translate(
+ 1, 3).arbitrary_point(s) == \
+ Line((0, 0), (1, 1)).rotate(pi/2, (1, 2)).scale(2, 3).translate(
+ 1, 3).arbitrary_point(s) == \
+ Point(-2*s + 7, 3*s + 6)
+
+ raises(ValueError, lambda: Curve((s), (s, 1, 2)))
+ raises(ValueError, lambda: Curve((x, x * 2), (1, x)))
+
+ raises(ValueError, lambda: Curve((s, s + t), (s, 1, 2)).arbitrary_point())
+ raises(ValueError, lambda: Curve((s, s + t), (t, 1, 2)).arbitrary_point(s))
+
+
+@slow
+def test_free_symbols():
+ a, b, c, d, e, f, s = symbols('a:f,s')
+ assert Point(a, b).free_symbols == {a, b}
+ assert Line((a, b), (c, d)).free_symbols == {a, b, c, d}
+ assert Ray((a, b), (c, d)).free_symbols == {a, b, c, d}
+ assert Ray((a, b), angle=c).free_symbols == {a, b, c}
+ assert Segment((a, b), (c, d)).free_symbols == {a, b, c, d}
+ assert Line((a, b), slope=c).free_symbols == {a, b, c}
+ assert Curve((a*s, b*s), (s, c, d)).free_symbols == {a, b, c, d}
+ assert Ellipse((a, b), c, d).free_symbols == {a, b, c, d}
+ assert Ellipse((a, b), c, eccentricity=d).free_symbols == \
+ {a, b, c, d}
+ assert Ellipse((a, b), vradius=c, eccentricity=d).free_symbols == \
+ {a, b, c, d}
+ assert Circle((a, b), c).free_symbols == {a, b, c}
+ assert Circle((a, b), (c, d), (e, f)).free_symbols == \
+ {e, d, c, b, f, a}
+ assert Polygon((a, b), (c, d), (e, f)).free_symbols == \
+ {e, b, d, f, a, c}
+ assert RegularPolygon((a, b), c, d, e).free_symbols == {e, a, b, c, d}
+
+
+def test_transform():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ c = Curve((x, x**2), (x, 0, 1))
+ cout = Curve((2*x - 4, 3*x**2 - 10), (x, 0, 1))
+ 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 c.scale(2, 3, (4, 5)) == cout
+ assert [c.subs(x, xi/2) for xi in Tuple(0, 1, 2)] == pts
+ assert [cout.subs(x, xi/2) for xi in Tuple(0, 1, 2)] == pts_out
+ assert Curve((x + y, 3*x), (x, 0, 1)).subs(y, S.Half) == \
+ Curve((x + S.Half, 3*x), (x, 0, 1))
+ assert Curve((x, 3*x), (x, 0, 1)).translate(4, 5) == \
+ Curve((x + 4, 3*x + 5), (x, 0, 1))
+
+
+def test_length():
+ t = Symbol('t', real=True)
+
+ c1 = Curve((t, 0), (t, 0, 1))
+ assert c1.length == 1
+
+ c2 = Curve((t, t), (t, 0, 1))
+ assert c2.length == sqrt(2)
+
+ c3 = Curve((t ** 2, t), (t, 2, 5))
+ assert c3.length == -sqrt(17) - asinh(4) / 4 + asinh(10) / 4 + 5 * sqrt(101) / 2
+
+
+def test_parameter_value():
+ t = Symbol('t')
+ C = Curve([2*t, t**2], (t, 0, 2))
+ assert C.parameter_value((2, 1), t) == {t: 1}
+ raises(ValueError, lambda: C.parameter_value((2, 0), t))
+
+
+def test_issue_17997():
+ t, s = symbols('t s')
+ c = Curve((t, t**2), (t, 0, 10))
+ p = Curve([2*s, s**2], (s, 0, 2))
+ assert c(2) == Point(2, 4)
+ assert p(1) == Point(2, 1)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_ellipse.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_ellipse.py
new file mode 100644
index 0000000000000000000000000000000000000000..385213f427d8780ada4c5775d0e53ab1f7e3e360
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_ellipse.py
@@ -0,0 +1,601 @@
+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 True
+ 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)]
+ 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 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 True
+ 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/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_entity.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_entity.py
new file mode 100644
index 0000000000000000000000000000000000000000..cecfdb785506d1b2f4ef496703c430794f09e589
--- /dev/null
+++ b/llmeval-env/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/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_geometrysets.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_geometrysets.py
new file mode 100644
index 0000000000000000000000000000000000000000..c52898b3c9ba4e9db80c244db3aebf88db2cc8b4
--- /dev/null
+++ b/llmeval-env/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/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_line.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_line.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ad154ad18e0550f9eecc5d2e289c731aed6e990
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_line.py
@@ -0,0 +1,852 @@
+from sympy.core.numbers import (Float, 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.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, cos, sin)
+from sympy.sets import EmptySet
+from sympy.simplify.simplify import simplify
+from sympy.functions.elementary.trigonometric import tan
+from sympy.geometry import (Circle, GeometryError, Line, Point, Ray,
+ Segment, Triangle, intersection, Point3D, Line3D, Ray3D, Segment3D,
+ Point2D, Line2D)
+from sympy.geometry.line import Undecidable
+from sympy.geometry.polygon import _asa as asa
+from sympy.utilities.iterables import cartes
+from sympy.testing.pytest import raises, warns
+
+
+x = Symbol('x', real=True)
+y = Symbol('y', real=True)
+z = Symbol('z', real=True)
+k = Symbol('k', real=True)
+x1 = Symbol('x1', real=True)
+y1 = Symbol('y1', real=True)
+t = Symbol('t', real=True)
+a, b = symbols('a,b', real=True)
+m = symbols('m', real=True)
+
+
+def test_object_from_equation():
+ from sympy.abc import x, y, a, b
+ assert Line(3*x + y + 18) == Line2D(Point2D(0, -18), Point2D(1, -21))
+ assert Line(3*x + 5 * y + 1) == Line2D(
+ Point2D(0, Rational(-1, 5)), Point2D(1, Rational(-4, 5)))
+ assert Line(3*a + b + 18, x="a", y="b") == Line2D(
+ Point2D(0, -18), Point2D(1, -21))
+ assert Line(3*x + y) == Line2D(Point2D(0, 0), Point2D(1, -3))
+ assert Line(x + y) == Line2D(Point2D(0, 0), Point2D(1, -1))
+ assert Line(Eq(3*a + b, -18), x="a", y=b) == Line2D(
+ Point2D(0, -18), Point2D(1, -21))
+ # issue 22361
+ assert Line(x - 1) == Line2D(Point2D(1, 0), Point2D(1, 1))
+ assert Line(2*x - 2, y=x) == Line2D(Point2D(0, 1), Point2D(1, 1))
+ assert Line(y) == Line2D(Point2D(0, 0), Point2D(1, 0))
+ assert Line(2*y, x=y) == Line2D(Point2D(0, 0), Point2D(0, 1))
+ assert Line(y, x=y) == Line2D(Point2D(0, 0), Point2D(0, 1))
+ raises(ValueError, lambda: Line(x / y))
+ raises(ValueError, lambda: Line(a / b, x='a', y='b'))
+ raises(ValueError, lambda: Line(y / x))
+ raises(ValueError, lambda: Line(b / a, x='a', y='b'))
+ raises(ValueError, lambda: Line((x + 1)**2 + y))
+
+
+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
+
+
+def test_angle_between():
+ a = Point(1, 2, 3, 4)
+ b = a.orthogonal_direction
+ o = a.origin
+ assert feq(Line.angle_between(Line(Point(0, 0), Point(1, 1)),
+ Line(Point(0, 0), Point(5, 0))).evalf(), pi.evalf() / 4)
+ assert Line(a, o).angle_between(Line(b, o)) == pi / 2
+ z = Point3D(0, 0, 0)
+ assert Line3D.angle_between(Line3D(z, Point3D(1, 1, 1)),
+ Line3D(z, Point3D(5, 0, 0))) == acos(sqrt(3) / 3)
+ # direction of points is used to determine angle
+ assert Line3D.angle_between(Line3D(z, Point3D(1, 1, 1)),
+ Line3D(Point3D(5, 0, 0), z)) == acos(-sqrt(3) / 3)
+
+
+def test_closing_angle():
+ a = Ray((0, 0), angle=0)
+ b = Ray((1, 2), angle=pi/2)
+ assert a.closing_angle(b) == -pi/2
+ assert b.closing_angle(a) == pi/2
+ assert a.closing_angle(a) == 0
+
+
+def test_smallest_angle():
+ a = Line(Point(1, 1), Point(1, 2))
+ b = Line(Point(1, 1),Point(2, 3))
+ assert a.smallest_angle_between(b) == acos(2*sqrt(5)/5)
+
+
+def test_svg():
+ a = Line(Point(1, 1),Point(1, 2))
+ assert a._svg() == ''
+ a = Segment(Point(1, 0),Point(1, 1))
+ assert a._svg() == ''
+ a = Ray(Point(2, 3), Point(3, 5))
+ assert a._svg() == ''
+
+
+def test_arbitrary_point():
+ l1 = Line3D(Point3D(0, 0, 0), Point3D(1, 1, 1))
+ l2 = Line(Point(x1, x1), Point(y1, y1))
+ assert l2.arbitrary_point() in l2
+ assert Ray((1, 1), angle=pi / 4).arbitrary_point() == \
+ Point(t + 1, t + 1)
+ assert Segment((1, 1), (2, 3)).arbitrary_point() == Point(1 + t, 1 + 2 * t)
+ assert l1.perpendicular_segment(l1.arbitrary_point()) == l1.arbitrary_point()
+ assert Ray3D((1, 1, 1), direction_ratio=[1, 2, 3]).arbitrary_point() == \
+ Point3D(t + 1, 2 * t + 1, 3 * t + 1)
+ assert Segment3D(Point3D(0, 0, 0), Point3D(1, 1, 1)).midpoint == \
+ Point3D(S.Half, S.Half, S.Half)
+ assert Segment3D(Point3D(x1, x1, x1), Point3D(y1, y1, y1)).length == sqrt(3) * sqrt((x1 - y1) ** 2)
+ assert Segment3D((1, 1, 1), (2, 3, 4)).arbitrary_point() == \
+ Point3D(t + 1, 2 * t + 1, 3 * t + 1)
+ raises(ValueError, (lambda: Line((x, 1), (2, 3)).arbitrary_point(x)))
+
+
+def test_are_concurrent_2d():
+ l1 = Line(Point(0, 0), Point(1, 1))
+ l2 = Line(Point(x1, x1), Point(x1, 1 + x1))
+ assert Line.are_concurrent(l1) is False
+ assert Line.are_concurrent(l1, l2)
+ assert Line.are_concurrent(l1, l1, l1, l2)
+ assert Line.are_concurrent(l1, l2, Line(Point(5, x1), Point(Rational(-3, 5), x1)))
+ assert Line.are_concurrent(l1, Line(Point(0, 0), Point(-x1, x1)), l2) is False
+
+
+def test_are_concurrent_3d():
+ p1 = Point3D(0, 0, 0)
+ l1 = Line(p1, Point3D(1, 1, 1))
+ parallel_1 = Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))
+ parallel_2 = Line3D(Point3D(0, 1, 0), Point3D(1, 1, 0))
+ assert Line3D.are_concurrent(l1) is False
+ assert Line3D.are_concurrent(l1, Line(Point3D(x1, x1, x1), Point3D(y1, y1, y1))) is False
+ assert Line3D.are_concurrent(l1, Line3D(p1, Point3D(x1, x1, x1)),
+ Line(Point3D(x1, x1, x1), Point3D(x1, 1 + x1, 1))) is True
+ assert Line3D.are_concurrent(parallel_1, parallel_2) is False
+
+
+def test_arguments():
+ """Functions accepting `Point` objects in `geometry`
+ should also accept tuples, lists, and generators and
+ automatically convert them to points."""
+ from sympy.utilities.iterables import subsets
+
+ singles2d = ((1, 2), [1, 3], Point(1, 5))
+ doubles2d = subsets(singles2d, 2)
+ l2d = Line(Point2D(1, 2), Point2D(2, 3))
+ singles3d = ((1, 2, 3), [1, 2, 4], Point(1, 2, 6))
+ doubles3d = subsets(singles3d, 2)
+ l3d = Line(Point3D(1, 2, 3), Point3D(1, 1, 2))
+ singles4d = ((1, 2, 3, 4), [1, 2, 3, 5], Point(1, 2, 3, 7))
+ doubles4d = subsets(singles4d, 2)
+ l4d = Line(Point(1, 2, 3, 4), Point(2, 2, 2, 2))
+ # test 2D
+ test_single = ['contains', 'distance', 'equals', 'parallel_line', 'perpendicular_line', 'perpendicular_segment',
+ 'projection', 'intersection']
+ for p in doubles2d:
+ Line2D(*p)
+ for func in test_single:
+ for p in singles2d:
+ getattr(l2d, func)(p)
+ # test 3D
+ for p in doubles3d:
+ Line3D(*p)
+ for func in test_single:
+ for p in singles3d:
+ getattr(l3d, func)(p)
+ # test 4D
+ for p in doubles4d:
+ Line(*p)
+ for func in test_single:
+ for p in singles4d:
+ getattr(l4d, func)(p)
+
+
+def test_basic_properties_2d():
+ p1 = Point(0, 0)
+ p2 = Point(1, 1)
+ p10 = Point(2000, 2000)
+ p_r3 = Ray(p1, p2).random_point()
+ p_r4 = Ray(p2, p1).random_point()
+
+ l1 = Line(p1, p2)
+ l3 = Line(Point(x1, x1), Point(x1, 1 + x1))
+ l4 = Line(p1, Point(1, 0))
+
+ r1 = Ray(p1, Point(0, 1))
+ r2 = Ray(Point(0, 1), p1)
+
+ s1 = Segment(p1, p10)
+ p_s1 = s1.random_point()
+
+ assert Line((1, 1), slope=1) == Line((1, 1), (2, 2))
+ assert Line((1, 1), slope=oo) == Line((1, 1), (1, 2))
+ assert Line((1, 1), slope=oo).bounds == (1, 1, 1, 2)
+ assert Line((1, 1), slope=-oo) == Line((1, 1), (1, 2))
+ assert Line(p1, p2).scale(2, 1) == Line(p1, Point(2, 1))
+ assert Line(p1, p2) == Line(p1, p2)
+ assert Line(p1, p2) != Line(p2, p1)
+ assert l1 != Line(Point(x1, x1), Point(y1, y1))
+ assert l1 != l3
+ assert Line(p1, p10) != Line(p10, p1)
+ assert Line(p1, p10) != p1
+ assert p1 in l1 # is p1 on the line l1?
+ assert p1 not in l3
+ assert s1 in Line(p1, p10)
+ assert Ray(Point(0, 0), Point(0, 1)) in Ray(Point(0, 0), Point(0, 2))
+ assert Ray(Point(0, 0), Point(0, 2)) in Ray(Point(0, 0), Point(0, 1))
+ assert Ray(Point(0, 0), Point(0, 2)).xdirection == S.Zero
+ assert Ray(Point(0, 0), Point(1, 2)).xdirection == S.Infinity
+ assert Ray(Point(0, 0), Point(-1, 2)).xdirection == S.NegativeInfinity
+ assert Ray(Point(0, 0), Point(2, 0)).ydirection == S.Zero
+ assert Ray(Point(0, 0), Point(2, 2)).ydirection == S.Infinity
+ assert Ray(Point(0, 0), Point(2, -2)).ydirection == S.NegativeInfinity
+ assert (r1 in s1) is False
+ assert Segment(p1, p2) in s1
+ assert Ray(Point(x1, x1), Point(x1, 1 + x1)) != Ray(p1, Point(-1, 5))
+ assert Segment(p1, p2).midpoint == Point(S.Half, S.Half)
+ assert Segment(p1, Point(-x1, x1)).length == sqrt(2 * (x1 ** 2))
+
+ assert l1.slope == 1
+ assert l3.slope is oo
+ assert l4.slope == 0
+ assert Line(p1, Point(0, 1)).slope is oo
+ assert Line(r1.source, r1.random_point()).slope == r1.slope
+ assert Line(r2.source, r2.random_point()).slope == r2.slope
+ assert Segment(Point(0, -1), Segment(p1, Point(0, 1)).random_point()).slope == Segment(p1, Point(0, 1)).slope
+
+ assert l4.coefficients == (0, 1, 0)
+ assert Line((-x, x), (-x + 1, x - 1)).coefficients == (1, 1, 0)
+ assert Line(p1, Point(0, 1)).coefficients == (1, 0, 0)
+ # issue 7963
+ r = Ray((0, 0), angle=x)
+ assert r.subs(x, 3 * pi / 4) == Ray((0, 0), (-1, 1))
+ assert r.subs(x, 5 * pi / 4) == Ray((0, 0), (-1, -1))
+ assert r.subs(x, -pi / 4) == Ray((0, 0), (1, -1))
+ assert r.subs(x, pi / 2) == Ray((0, 0), (0, 1))
+ assert r.subs(x, -pi / 2) == Ray((0, 0), (0, -1))
+
+ for ind in range(0, 5):
+ assert l3.random_point() in l3
+
+ assert p_r3.x >= p1.x and p_r3.y >= p1.y
+ assert p_r4.x <= p2.x and p_r4.y <= p2.y
+ assert p1.x <= p_s1.x <= p10.x and p1.y <= p_s1.y <= p10.y
+ assert hash(s1) != hash(Segment(p10, p1))
+
+ assert s1.plot_interval() == [t, 0, 1]
+ assert Line(p1, p10).plot_interval() == [t, -5, 5]
+ assert Ray((0, 0), angle=pi / 4).plot_interval() == [t, 0, 10]
+
+
+def test_basic_properties_3d():
+ p1 = Point3D(0, 0, 0)
+ p2 = Point3D(1, 1, 1)
+ p3 = Point3D(x1, x1, x1)
+ p5 = Point3D(x1, 1 + x1, 1)
+
+ l1 = Line3D(p1, p2)
+ l3 = Line3D(p3, p5)
+
+ r1 = Ray3D(p1, Point3D(-1, 5, 0))
+ r3 = Ray3D(p1, p2)
+
+ s1 = Segment3D(p1, p2)
+
+ assert Line3D((1, 1, 1), direction_ratio=[2, 3, 4]) == Line3D(Point3D(1, 1, 1), Point3D(3, 4, 5))
+ assert Line3D((1, 1, 1), direction_ratio=[1, 5, 7]) == Line3D(Point3D(1, 1, 1), Point3D(2, 6, 8))
+ assert Line3D((1, 1, 1), direction_ratio=[1, 2, 3]) == Line3D(Point3D(1, 1, 1), Point3D(2, 3, 4))
+ assert Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0)).direction_cosine == [1, 0, 0]
+ assert Line3D(Line3D(p1, Point3D(0, 1, 0))) == Line3D(p1, Point3D(0, 1, 0))
+ assert Ray3D(Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))) == Ray3D(p1, Point3D(1, 0, 0))
+ assert Line3D(p1, p2) != Line3D(p2, p1)
+ assert l1 != l3
+ assert l1 != Line3D(p3, Point3D(y1, y1, y1))
+ assert r3 != r1
+ assert Ray3D(Point3D(0, 0, 0), Point3D(1, 1, 1)) in Ray3D(Point3D(0, 0, 0), Point3D(2, 2, 2))
+ assert Ray3D(Point3D(0, 0, 0), Point3D(2, 2, 2)) in Ray3D(Point3D(0, 0, 0), Point3D(1, 1, 1))
+ assert Ray3D(Point3D(0, 0, 0), Point3D(2, 2, 2)).xdirection == S.Infinity
+ assert Ray3D(Point3D(0, 0, 0), Point3D(2, 2, 2)).ydirection == S.Infinity
+ assert Ray3D(Point3D(0, 0, 0), Point3D(2, 2, 2)).zdirection == S.Infinity
+ assert Ray3D(Point3D(0, 0, 0), Point3D(-2, 2, 2)).xdirection == S.NegativeInfinity
+ assert Ray3D(Point3D(0, 0, 0), Point3D(2, -2, 2)).ydirection == S.NegativeInfinity
+ assert Ray3D(Point3D(0, 0, 0), Point3D(2, 2, -2)).zdirection == S.NegativeInfinity
+ assert Ray3D(Point3D(0, 0, 0), Point3D(0, 2, 2)).xdirection == S.Zero
+ assert Ray3D(Point3D(0, 0, 0), Point3D(2, 0, 2)).ydirection == S.Zero
+ assert Ray3D(Point3D(0, 0, 0), Point3D(2, 2, 0)).zdirection == S.Zero
+ assert p1 in l1
+ assert p1 not in l3
+
+ assert l1.direction_ratio == [1, 1, 1]
+
+ assert s1.midpoint == Point3D(S.Half, S.Half, S.Half)
+ # Test zdirection
+ assert Ray3D(p1, Point3D(0, 0, -1)).zdirection is S.NegativeInfinity
+
+
+def test_contains():
+ p1 = Point(0, 0)
+
+ r = Ray(p1, Point(4, 4))
+ r1 = Ray3D(p1, Point3D(0, 0, -1))
+ r2 = Ray3D(p1, Point3D(0, 1, 0))
+ r3 = Ray3D(p1, Point3D(0, 0, 1))
+
+ l = Line(Point(0, 1), Point(3, 4))
+ # Segment contains
+ assert Point(0, (a + b) / 2) in Segment((0, a), (0, b))
+ assert Point((a + b) / 2, 0) in Segment((a, 0), (b, 0))
+ assert Point3D(0, 1, 0) in Segment3D((0, 1, 0), (0, 1, 0))
+ assert Point3D(1, 0, 0) in Segment3D((1, 0, 0), (1, 0, 0))
+ assert Segment3D(Point3D(0, 0, 0), Point3D(1, 0, 0)).contains([]) is True
+ assert Segment3D(Point3D(0, 0, 0), Point3D(1, 0, 0)).contains(
+ Segment3D(Point3D(2, 2, 2), Point3D(3, 2, 2))) is False
+ # Line contains
+ assert l.contains(Point(0, 1)) is True
+ assert l.contains((0, 1)) is True
+ assert l.contains((0, 0)) is False
+ # Ray contains
+ assert r.contains(p1) is True
+ assert r.contains((1, 1)) is True
+ assert r.contains((1, 3)) is False
+ assert r.contains(Segment((1, 1), (2, 2))) is True
+ assert r.contains(Segment((1, 2), (2, 5))) is False
+ assert r.contains(Ray((2, 2), (3, 3))) is True
+ assert r.contains(Ray((2, 2), (3, 5))) is False
+ assert r1.contains(Segment3D(p1, Point3D(0, 0, -10))) is True
+ assert r1.contains(Segment3D(Point3D(1, 1, 1), Point3D(2, 2, 2))) is False
+ assert r2.contains(Point3D(0, 0, 0)) is True
+ assert r3.contains(Point3D(0, 0, 0)) is True
+ assert Ray3D(Point3D(1, 1, 1), Point3D(1, 0, 0)).contains([]) is False
+ assert Line3D((0, 0, 0), (x, y, z)).contains((2 * x, 2 * y, 2 * z))
+ with warns(UserWarning, test_stacklevel=False):
+ assert Line3D(p1, Point3D(0, 1, 0)).contains(Point(1.0, 1.0)) is False
+
+ with warns(UserWarning, test_stacklevel=False):
+ assert r3.contains(Point(1.0, 1.0)) is False
+
+
+def test_contains_nonreal_symbols():
+ u, v, w, z = symbols('u, v, w, z')
+ l = Segment(Point(u, w), Point(v, z))
+ p = Point(u*Rational(2, 3) + v/3, w*Rational(2, 3) + z/3)
+ assert l.contains(p)
+
+
+def test_distance_2d():
+ p1 = Point(0, 0)
+ p2 = Point(1, 1)
+ half = S.Half
+
+ s1 = Segment(Point(0, 0), Point(1, 1))
+ s2 = Segment(Point(half, half), Point(1, 0))
+
+ r = Ray(p1, p2)
+
+ assert s1.distance(Point(0, 0)) == 0
+ assert s1.distance((0, 0)) == 0
+ assert s2.distance(Point(0, 0)) == 2 ** half / 2
+ assert s2.distance(Point(Rational(3) / 2, Rational(3) / 2)) == 2 ** half
+ assert Line(p1, p2).distance(Point(-1, 1)) == sqrt(2)
+ assert Line(p1, p2).distance(Point(1, -1)) == sqrt(2)
+ assert Line(p1, p2).distance(Point(2, 2)) == 0
+ assert Line(p1, p2).distance((-1, 1)) == sqrt(2)
+ assert Line((0, 0), (0, 1)).distance(p1) == 0
+ assert Line((0, 0), (0, 1)).distance(p2) == 1
+ assert Line((0, 0), (1, 0)).distance(p1) == 0
+ assert Line((0, 0), (1, 0)).distance(p2) == 1
+ assert r.distance(Point(-1, -1)) == sqrt(2)
+ assert r.distance(Point(1, 1)) == 0
+ assert r.distance(Point(-1, 1)) == sqrt(2)
+ assert Ray((1, 1), (2, 2)).distance(Point(1.5, 3)) == 3 * sqrt(2) / 4
+ assert r.distance((1, 1)) == 0
+
+
+def test_dimension_normalization():
+ with warns(UserWarning, test_stacklevel=False):
+ assert Ray((1, 1), (2, 1, 2)) == Ray((1, 1, 0), (2, 1, 2))
+
+
+def test_distance_3d():
+ p1, p2 = Point3D(0, 0, 0), Point3D(1, 1, 1)
+ p3 = Point3D(Rational(3) / 2, Rational(3) / 2, Rational(3) / 2)
+
+ s1 = Segment3D(Point3D(0, 0, 0), Point3D(1, 1, 1))
+ s2 = Segment3D(Point3D(S.Half, S.Half, S.Half), Point3D(1, 0, 1))
+
+ r = Ray3D(p1, p2)
+
+ assert s1.distance(p1) == 0
+ assert s2.distance(p1) == sqrt(3) / 2
+ assert s2.distance(p3) == 2 * sqrt(6) / 3
+ assert s1.distance((0, 0, 0)) == 0
+ assert s2.distance((0, 0, 0)) == sqrt(3) / 2
+ assert s1.distance(p1) == 0
+ assert s2.distance(p1) == sqrt(3) / 2
+ assert s2.distance(p3) == 2 * sqrt(6) / 3
+ assert s1.distance((0, 0, 0)) == 0
+ assert s2.distance((0, 0, 0)) == sqrt(3) / 2
+ # Line to point
+ assert Line3D(p1, p2).distance(Point3D(-1, 1, 1)) == 2 * sqrt(6) / 3
+ assert Line3D(p1, p2).distance(Point3D(1, -1, 1)) == 2 * sqrt(6) / 3
+ assert Line3D(p1, p2).distance(Point3D(2, 2, 2)) == 0
+ assert Line3D(p1, p2).distance((2, 2, 2)) == 0
+ assert Line3D(p1, p2).distance((1, -1, 1)) == 2 * sqrt(6) / 3
+ assert Line3D((0, 0, 0), (0, 1, 0)).distance(p1) == 0
+ assert Line3D((0, 0, 0), (0, 1, 0)).distance(p2) == sqrt(2)
+ assert Line3D((0, 0, 0), (1, 0, 0)).distance(p1) == 0
+ assert Line3D((0, 0, 0), (1, 0, 0)).distance(p2) == sqrt(2)
+ # Ray to point
+ assert r.distance(Point3D(-1, -1, -1)) == sqrt(3)
+ assert r.distance(Point3D(1, 1, 1)) == 0
+ assert r.distance((-1, -1, -1)) == sqrt(3)
+ assert r.distance((1, 1, 1)) == 0
+ assert Ray3D((0, 0, 0), (1, 1, 2)).distance((-1, -1, 2)) == 4 * sqrt(3) / 3
+ assert Ray3D((1, 1, 1), (2, 2, 2)).distance(Point3D(1.5, -3, -1)) == Rational(9) / 2
+ assert Ray3D((1, 1, 1), (2, 2, 2)).distance(Point3D(1.5, 3, 1)) == sqrt(78) / 6
+
+
+def test_equals():
+ p1 = Point(0, 0)
+ p2 = Point(1, 1)
+
+ l1 = Line(p1, p2)
+ l2 = Line((0, 5), slope=m)
+ l3 = Line(Point(x1, x1), Point(x1, 1 + x1))
+
+ assert l1.perpendicular_line(p1.args).equals(Line(Point(0, 0), Point(1, -1)))
+ assert l1.perpendicular_line(p1).equals(Line(Point(0, 0), Point(1, -1)))
+ assert Line(Point(x1, x1), Point(y1, y1)).parallel_line(Point(-x1, x1)). \
+ equals(Line(Point(-x1, x1), Point(-y1, 2 * x1 - y1)))
+ assert l3.parallel_line(p1.args).equals(Line(Point(0, 0), Point(0, -1)))
+ assert l3.parallel_line(p1).equals(Line(Point(0, 0), Point(0, -1)))
+ assert (l2.distance(Point(2, 3)) - 2 * abs(m + 1) / sqrt(m ** 2 + 1)).equals(0)
+ assert Line3D(p1, Point3D(0, 1, 0)).equals(Point(1.0, 1.0)) is False
+ assert Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0)).equals(Line3D(Point3D(-5, 0, 0), Point3D(-1, 0, 0))) is True
+ assert Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0)).equals(Line3D(p1, Point3D(0, 1, 0))) is False
+ assert Ray3D(p1, Point3D(0, 0, -1)).equals(Point(1.0, 1.0)) is False
+ assert Ray3D(p1, Point3D(0, 0, -1)).equals(Ray3D(p1, Point3D(0, 0, -1))) is True
+ assert Line3D((0, 0), (t, t)).perpendicular_line(Point(0, 1, 0)).equals(
+ Line3D(Point3D(0, 1, 0), Point3D(S.Half, S.Half, 0)))
+ assert Line3D((0, 0), (t, t)).perpendicular_segment(Point(0, 1, 0)).equals(Segment3D((0, 1), (S.Half, S.Half)))
+ assert Line3D(p1, Point3D(0, 1, 0)).equals(Point(1.0, 1.0)) is False
+
+
+def test_equation():
+ p1 = Point(0, 0)
+ p2 = Point(1, 1)
+ l1 = Line(p1, p2)
+ l3 = Line(Point(x1, x1), Point(x1, 1 + x1))
+
+ assert simplify(l1.equation()) in (x - y, y - x)
+ assert simplify(l3.equation()) in (x - x1, x1 - x)
+ assert simplify(l1.equation()) in (x - y, y - x)
+ assert simplify(l3.equation()) in (x - x1, x1 - x)
+
+ assert Line(p1, Point(1, 0)).equation(x=x, y=y) == y
+ assert Line(p1, Point(0, 1)).equation() == x
+ assert Line(Point(2, 0), Point(2, 1)).equation() == x - 2
+ assert Line(p2, Point(2, 1)).equation() == y - 1
+
+ assert Line3D(Point(x1, x1, x1), Point(y1, y1, y1)
+ ).equation() == (-x + y, -x + z)
+ assert Line3D(Point(1, 2, 3), Point(2, 3, 4)
+ ).equation() == (-x + y - 1, -x + z - 2)
+ assert Line3D(Point(1, 2, 3), Point(1, 3, 4)
+ ).equation() == (x - 1, -y + z - 1)
+ assert Line3D(Point(1, 2, 3), Point(2, 2, 4)
+ ).equation() == (y - 2, -x + z - 2)
+ assert Line3D(Point(1, 2, 3), Point(2, 3, 3)
+ ).equation() == (-x + y - 1, z - 3)
+ assert Line3D(Point(1, 2, 3), Point(1, 2, 4)
+ ).equation() == (x - 1, y - 2)
+ assert Line3D(Point(1, 2, 3), Point(1, 3, 3)
+ ).equation() == (x - 1, z - 3)
+ assert Line3D(Point(1, 2, 3), Point(2, 2, 3)
+ ).equation() == (y - 2, z - 3)
+
+
+def test_intersection_2d():
+ p1 = Point(0, 0)
+ p2 = Point(1, 1)
+ p3 = Point(x1, x1)
+ p4 = Point(y1, y1)
+
+ l1 = Line(p1, p2)
+ l3 = Line(Point(0, 0), Point(3, 4))
+
+ r1 = Ray(Point(1, 1), Point(2, 2))
+ r2 = Ray(Point(0, 0), Point(3, 4))
+ r4 = Ray(p1, p2)
+ r6 = Ray(Point(0, 1), Point(1, 2))
+ r7 = Ray(Point(0.5, 0.5), Point(1, 1))
+
+ s1 = Segment(p1, p2)
+ s2 = Segment(Point(0.25, 0.25), Point(0.5, 0.5))
+ s3 = Segment(Point(0, 0), Point(3, 4))
+
+ assert intersection(l1, p1) == [p1]
+ assert intersection(l1, Point(x1, 1 + x1)) == []
+ assert intersection(l1, Line(p3, p4)) in [[l1], [Line(p3, p4)]]
+ assert intersection(l1, l1.parallel_line(Point(x1, 1 + x1))) == []
+ assert intersection(l3, l3) == [l3]
+ assert intersection(l3, r2) == [r2]
+ assert intersection(l3, s3) == [s3]
+ assert intersection(s3, l3) == [s3]
+ assert intersection(Segment(Point(-10, 10), Point(10, 10)), Segment(Point(-5, -5), Point(-5, 5))) == []
+ assert intersection(r2, l3) == [r2]
+ assert intersection(r1, Ray(Point(2, 2), Point(0, 0))) == [Segment(Point(1, 1), Point(2, 2))]
+ assert intersection(r1, Ray(Point(1, 1), Point(-1, -1))) == [Point(1, 1)]
+ assert intersection(r1, Segment(Point(0, 0), Point(2, 2))) == [Segment(Point(1, 1), Point(2, 2))]
+
+ assert r4.intersection(s2) == [s2]
+ assert r4.intersection(Segment(Point(2, 3), Point(3, 4))) == []
+ assert r4.intersection(Segment(Point(-1, -1), Point(0.5, 0.5))) == [Segment(p1, Point(0.5, 0.5))]
+ assert r4.intersection(Ray(p2, p1)) == [s1]
+ assert Ray(p2, p1).intersection(r6) == []
+ assert r4.intersection(r7) == r7.intersection(r4) == [r7]
+ assert Ray3D((0, 0), (3, 0)).intersection(Ray3D((1, 0), (3, 0))) == [Ray3D((1, 0), (3, 0))]
+ assert Ray3D((1, 0), (3, 0)).intersection(Ray3D((0, 0), (3, 0))) == [Ray3D((1, 0), (3, 0))]
+ assert Ray(Point(0, 0), Point(0, 4)).intersection(Ray(Point(0, 1), Point(0, -1))) == \
+ [Segment(Point(0, 0), Point(0, 1))]
+
+ assert Segment3D((0, 0), (3, 0)).intersection(
+ Segment3D((1, 0), (2, 0))) == [Segment3D((1, 0), (2, 0))]
+ assert Segment3D((1, 0), (2, 0)).intersection(
+ Segment3D((0, 0), (3, 0))) == [Segment3D((1, 0), (2, 0))]
+ assert Segment3D((0, 0), (3, 0)).intersection(
+ Segment3D((3, 0), (4, 0))) == [Point3D((3, 0))]
+ assert Segment3D((0, 0), (3, 0)).intersection(
+ Segment3D((2, 0), (5, 0))) == [Segment3D((2, 0), (3, 0))]
+ assert Segment3D((0, 0), (3, 0)).intersection(
+ Segment3D((-2, 0), (1, 0))) == [Segment3D((0, 0), (1, 0))]
+ assert Segment3D((0, 0), (3, 0)).intersection(
+ Segment3D((-2, 0), (0, 0))) == [Point3D(0, 0)]
+ assert s1.intersection(Segment(Point(1, 1), Point(2, 2))) == [Point(1, 1)]
+ assert s1.intersection(Segment(Point(0.5, 0.5), Point(1.5, 1.5))) == [Segment(Point(0.5, 0.5), p2)]
+ assert s1.intersection(Segment(Point(4, 4), Point(5, 5))) == []
+ assert s1.intersection(Segment(Point(-1, -1), p1)) == [p1]
+ assert s1.intersection(Segment(Point(-1, -1), Point(0.5, 0.5))) == [Segment(p1, Point(0.5, 0.5))]
+ assert s1.intersection(Line(Point(1, 0), Point(2, 1))) == []
+ assert s1.intersection(s2) == [s2]
+ assert s2.intersection(s1) == [s2]
+
+ assert asa(120, 8, 52) == \
+ Triangle(
+ Point(0, 0),
+ Point(8, 0),
+ Point(-4 * cos(19 * pi / 90) / sin(2 * pi / 45),
+ 4 * sqrt(3) * cos(19 * pi / 90) / sin(2 * pi / 45)))
+ assert Line((0, 0), (1, 1)).intersection(Ray((1, 0), (1, 2))) == [Point(1, 1)]
+ assert Line((0, 0), (1, 1)).intersection(Segment((1, 0), (1, 2))) == [Point(1, 1)]
+ assert Ray((0, 0), (1, 1)).intersection(Ray((1, 0), (1, 2))) == [Point(1, 1)]
+ assert Ray((0, 0), (1, 1)).intersection(Segment((1, 0), (1, 2))) == [Point(1, 1)]
+ assert Ray((0, 0), (10, 10)).contains(Segment((1, 1), (2, 2))) is True
+ assert Segment((1, 1), (2, 2)) in Line((0, 0), (10, 10))
+ assert s1.intersection(Ray((1, 1), (4, 4))) == [Point(1, 1)]
+
+ # This test is disabled because it hangs after rref changes which simplify
+ # intermediate results and return a different representation from when the
+ # test was written.
+ # # 16628 - this should be fast
+ # p0 = Point2D(Rational(249, 5), Rational(497999, 10000))
+ # p1 = Point2D((-58977084786*sqrt(405639795226) + 2030690077184193 +
+ # 20112207807*sqrt(630547164901) + 99600*sqrt(255775022850776494562626))
+ # /(2000*sqrt(255775022850776494562626) + 1991998000*sqrt(405639795226)
+ # + 1991998000*sqrt(630547164901) + 1622561172902000),
+ # (-498000*sqrt(255775022850776494562626) - 995999*sqrt(630547164901) +
+ # 90004251917891999 +
+ # 496005510002*sqrt(405639795226))/(10000*sqrt(255775022850776494562626)
+ # + 9959990000*sqrt(405639795226) + 9959990000*sqrt(630547164901) +
+ # 8112805864510000))
+ # p2 = Point2D(Rational(497, 10), Rational(-497, 10))
+ # p3 = Point2D(Rational(-497, 10), Rational(-497, 10))
+ # l = Line(p0, p1)
+ # s = Segment(p2, p3)
+ # n = (-52673223862*sqrt(405639795226) - 15764156209307469 -
+ # 9803028531*sqrt(630547164901) +
+ # 33200*sqrt(255775022850776494562626))
+ # d = sqrt(405639795226) + 315274080450 + 498000*sqrt(
+ # 630547164901) + sqrt(255775022850776494562626)
+ # assert intersection(l, s) == [
+ # Point2D(n/d*Rational(3, 2000), Rational(-497, 10))]
+
+
+def test_line_intersection():
+ # see also test_issue_11238 in test_matrices.py
+ x0 = tan(pi*Rational(13, 45))
+ x1 = sqrt(3)
+ x2 = x0**2
+ x, y = [8*x0/(x0 + x1), (24*x0 - 8*x1*x2)/(x2 - 3)]
+ assert Line(Point(0, 0), Point(1, -sqrt(3))).contains(Point(x, y)) is True
+
+
+def test_intersection_3d():
+ p1 = Point3D(0, 0, 0)
+ p2 = Point3D(1, 1, 1)
+
+ l1 = Line3D(p1, p2)
+ l2 = Line3D(Point3D(0, 0, 0), Point3D(3, 4, 0))
+
+ r1 = Ray3D(Point3D(1, 1, 1), Point3D(2, 2, 2))
+ r2 = Ray3D(Point3D(0, 0, 0), Point3D(3, 4, 0))
+
+ s1 = Segment3D(Point3D(0, 0, 0), Point3D(3, 4, 0))
+
+ assert intersection(l1, p1) == [p1]
+ assert intersection(l1, Point3D(x1, 1 + x1, 1)) == []
+ assert intersection(l1, l1.parallel_line(p1)) == [Line3D(Point3D(0, 0, 0), Point3D(1, 1, 1))]
+ assert intersection(l2, r2) == [r2]
+ assert intersection(l2, s1) == [s1]
+ assert intersection(r2, l2) == [r2]
+ assert intersection(r1, Ray3D(Point3D(1, 1, 1), Point3D(-1, -1, -1))) == [Point3D(1, 1, 1)]
+ assert intersection(r1, Segment3D(Point3D(0, 0, 0), Point3D(2, 2, 2))) == [
+ Segment3D(Point3D(1, 1, 1), Point3D(2, 2, 2))]
+ assert intersection(Ray3D(Point3D(1, 0, 0), Point3D(-1, 0, 0)), Ray3D(Point3D(0, 1, 0), Point3D(0, -1, 0))) \
+ == [Point3D(0, 0, 0)]
+ assert intersection(r1, Ray3D(Point3D(2, 2, 2), Point3D(0, 0, 0))) == \
+ [Segment3D(Point3D(1, 1, 1), Point3D(2, 2, 2))]
+ assert intersection(s1, r2) == [s1]
+
+ assert Line3D(Point3D(4, 0, 1), Point3D(0, 4, 1)).intersection(Line3D(Point3D(0, 0, 1), Point3D(4, 4, 1))) == \
+ [Point3D(2, 2, 1)]
+ assert Line3D((0, 1, 2), (0, 2, 3)).intersection(Line3D((0, 1, 2), (0, 1, 1))) == [Point3D(0, 1, 2)]
+ assert Line3D((0, 0), (t, t)).intersection(Line3D((0, 1), (t, t))) == \
+ [Point3D(t, t)]
+
+ assert Ray3D(Point3D(0, 0, 0), Point3D(0, 4, 0)).intersection(Ray3D(Point3D(0, 1, 1), Point3D(0, -1, 1))) == []
+
+
+def test_is_parallel():
+ p1 = Point3D(0, 0, 0)
+ p2 = Point3D(1, 1, 1)
+ p3 = Point3D(x1, x1, x1)
+
+ l2 = Line(Point(x1, x1), Point(y1, y1))
+ l2_1 = Line(Point(x1, x1), Point(x1, 1 + x1))
+
+ assert Line.is_parallel(Line(Point(0, 0), Point(1, 1)), l2)
+ assert Line.is_parallel(l2, Line(Point(x1, x1), Point(x1, 1 + x1))) is False
+ assert Line.is_parallel(l2, l2.parallel_line(Point(-x1, x1)))
+ assert Line.is_parallel(l2_1, l2_1.parallel_line(Point(0, 0)))
+ assert Line3D(p1, p2).is_parallel(Line3D(p1, p2)) # same as in 2D
+ assert Line3D(Point3D(4, 0, 1), Point3D(0, 4, 1)).is_parallel(Line3D(Point3D(0, 0, 1), Point3D(4, 4, 1))) is False
+ assert Line3D(p1, p2).parallel_line(p3) == Line3D(Point3D(x1, x1, x1),
+ Point3D(x1 + 1, x1 + 1, x1 + 1))
+ assert Line3D(p1, p2).parallel_line(p3.args) == \
+ Line3D(Point3D(x1, x1, x1), Point3D(x1 + 1, x1 + 1, x1 + 1))
+ assert Line3D(Point3D(4, 0, 1), Point3D(0, 4, 1)).is_parallel(Line3D(Point3D(0, 0, 1), Point3D(4, 4, 1))) is False
+
+
+def test_is_perpendicular():
+ p1 = Point(0, 0)
+ p2 = Point(1, 1)
+
+ l1 = Line(p1, p2)
+ l2 = Line(Point(x1, x1), Point(y1, y1))
+ l1_1 = Line(p1, Point(-x1, x1))
+ # 2D
+ assert Line.is_perpendicular(l1, l1_1)
+ assert Line.is_perpendicular(l1, l2) is False
+ p = l1.random_point()
+ assert l1.perpendicular_segment(p) == p
+ # 3D
+ assert Line3D.is_perpendicular(Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0)),
+ Line3D(Point3D(0, 0, 0), Point3D(0, 1, 0))) is True
+ assert Line3D.is_perpendicular(Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0)),
+ Line3D(Point3D(0, 1, 0), Point3D(1, 1, 0))) is False
+ assert Line3D.is_perpendicular(Line3D(Point3D(0, 0, 0), Point3D(1, 1, 1)),
+ Line3D(Point3D(x1, x1, x1), Point3D(y1, y1, y1))) is False
+
+
+def test_is_similar():
+ p1 = Point(2000, 2000)
+ p2 = p1.scale(2, 2)
+
+ r1 = Ray3D(Point3D(1, 1, 1), Point3D(1, 0, 0))
+ r2 = Ray(Point(0, 0), Point(0, 1))
+
+ s1 = Segment(Point(0, 0), p1)
+
+ assert s1.is_similar(Segment(p1, p2))
+ assert s1.is_similar(r2) is False
+ assert r1.is_similar(Line3D(Point3D(1, 1, 1), Point3D(1, 0, 0))) is True
+ assert r1.is_similar(Line3D(Point3D(0, 0, 0), Point3D(0, 1, 0))) is False
+
+
+def test_length():
+ s2 = Segment3D(Point3D(x1, x1, x1), Point3D(y1, y1, y1))
+ assert Line(Point(0, 0), Point(1, 1)).length is oo
+ assert s2.length == sqrt(3) * sqrt((x1 - y1) ** 2)
+ assert Line3D(Point3D(0, 0, 0), Point3D(1, 1, 1)).length is oo
+
+
+def test_projection():
+ p1 = Point(0, 0)
+ p2 = Point3D(0, 0, 0)
+ p3 = Point(-x1, x1)
+
+ l1 = Line(p1, Point(1, 1))
+ l2 = Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))
+ l3 = Line3D(p2, Point3D(1, 1, 1))
+
+ r1 = Ray(Point(1, 1), Point(2, 2))
+
+ s1 = Segment(Point2D(0, 0), Point2D(0, 1))
+ s2 = Segment(Point2D(1, 0), Point2D(2, 1/2))
+
+ assert Line(Point(x1, x1), Point(y1, y1)).projection(Point(y1, y1)) == Point(y1, y1)
+ assert Line(Point(x1, x1), Point(x1, 1 + x1)).projection(Point(1, 1)) == Point(x1, 1)
+ assert Segment(Point(-2, 2), Point(0, 4)).projection(r1) == Segment(Point(-1, 3), Point(0, 4))
+ assert Segment(Point(0, 4), Point(-2, 2)).projection(r1) == Segment(Point(0, 4), Point(-1, 3))
+ assert s2.projection(s1) == EmptySet
+ assert l1.projection(p3) == p1
+ assert l1.projection(Ray(p1, Point(-1, 5))) == Ray(Point(0, 0), Point(2, 2))
+ assert l1.projection(Ray(p1, Point(-1, 1))) == p1
+ assert r1.projection(Ray(Point(1, 1), Point(-1, -1))) == Point(1, 1)
+ assert r1.projection(Ray(Point(0, 4), Point(-1, -5))) == Segment(Point(1, 1), Point(2, 2))
+ assert r1.projection(Segment(Point(-1, 5), Point(-5, -10))) == Segment(Point(1, 1), Point(2, 2))
+ assert r1.projection(Ray(Point(1, 1), Point(-1, -1))) == Point(1, 1)
+ assert r1.projection(Ray(Point(0, 4), Point(-1, -5))) == Segment(Point(1, 1), Point(2, 2))
+ assert r1.projection(Segment(Point(-1, 5), Point(-5, -10))) == Segment(Point(1, 1), Point(2, 2))
+
+ assert l3.projection(Ray3D(p2, Point3D(-1, 5, 0))) == Ray3D(Point3D(0, 0, 0), Point3D(Rational(4, 3), Rational(4, 3), Rational(4, 3)))
+ assert l3.projection(Ray3D(p2, Point3D(-1, 1, 1))) == Ray3D(Point3D(0, 0, 0), Point3D(Rational(1, 3), Rational(1, 3), Rational(1, 3)))
+ assert l2.projection(Point3D(5, 5, 0)) == Point3D(5, 0)
+ assert l2.projection(Line3D(Point3D(0, 1, 0), Point3D(1, 1, 0))).equals(l2)
+
+
+def test_perpendicular_line():
+ # 3d - requires a particular orthogonal to be selected
+ p1, p2, p3 = Point(0, 0, 0), Point(2, 3, 4), Point(-2, 2, 0)
+ l = Line(p1, p2)
+ p = l.perpendicular_line(p3)
+ assert p.p1 == p3
+ assert p.p2 in l
+ # 2d - does not require special selection
+ p1, p2, p3 = Point(0, 0), Point(2, 3), Point(-2, 2)
+ l = Line(p1, p2)
+ p = l.perpendicular_line(p3)
+ assert p.p1 == p3
+ # p is directed from l to p3
+ assert p.direction.unit == (p3 - l.projection(p3)).unit
+
+
+def test_perpendicular_bisector():
+ s1 = Segment(Point(0, 0), Point(1, 1))
+ aline = Line(Point(S.Half, S.Half), Point(Rational(3, 2), Rational(-1, 2)))
+ on_line = Segment(Point(S.Half, S.Half), Point(Rational(3, 2), Rational(-1, 2))).midpoint
+
+ assert s1.perpendicular_bisector().equals(aline)
+ assert s1.perpendicular_bisector(on_line).equals(Segment(s1.midpoint, on_line))
+ assert s1.perpendicular_bisector(on_line + (1, 0)).equals(aline)
+
+
+def test_raises():
+ d, e = symbols('a,b', real=True)
+ s = Segment((d, 0), (e, 0))
+
+ raises(TypeError, lambda: Line((1, 1), 1))
+ raises(ValueError, lambda: Line(Point(0, 0), Point(0, 0)))
+ raises(Undecidable, lambda: Point(2 * d, 0) in s)
+ raises(ValueError, lambda: Ray3D(Point(1.0, 1.0)))
+ raises(ValueError, lambda: Line3D(Point3D(0, 0, 0), Point3D(0, 0, 0)))
+ raises(TypeError, lambda: Line3D((1, 1), 1))
+ raises(ValueError, lambda: Line3D(Point3D(0, 0, 0)))
+ raises(TypeError, lambda: Ray((1, 1), 1))
+ raises(GeometryError, lambda: Line(Point(0, 0), Point(1, 0))
+ .projection(Circle(Point(0, 0), 1)))
+
+
+def test_ray_generation():
+ assert Ray((1, 1), angle=pi / 4) == Ray((1, 1), (2, 2))
+ assert Ray((1, 1), angle=pi / 2) == Ray((1, 1), (1, 2))
+ assert Ray((1, 1), angle=-pi / 2) == Ray((1, 1), (1, 0))
+ assert Ray((1, 1), angle=-3 * pi / 2) == Ray((1, 1), (1, 2))
+ assert Ray((1, 1), angle=5 * pi / 2) == Ray((1, 1), (1, 2))
+ assert Ray((1, 1), angle=5.0 * pi / 2) == Ray((1, 1), (1, 2))
+ assert Ray((1, 1), angle=pi) == Ray((1, 1), (0, 1))
+ assert Ray((1, 1), angle=3.0 * pi) == Ray((1, 1), (0, 1))
+ assert Ray((1, 1), angle=4.0 * pi) == Ray((1, 1), (2, 1))
+ assert Ray((1, 1), angle=0) == Ray((1, 1), (2, 1))
+ assert Ray((1, 1), angle=4.05 * pi) == Ray(Point(1, 1),
+ Point(2, -sqrt(5) * sqrt(2 * sqrt(5) + 10) / 4 - sqrt(
+ 2 * sqrt(5) + 10) / 4 + 2 + sqrt(5)))
+ assert Ray((1, 1), angle=4.02 * pi) == Ray(Point(1, 1),
+ Point(2, 1 + tan(4.02 * pi)))
+ assert Ray((1, 1), angle=5) == Ray((1, 1), (2, 1 + tan(5)))
+
+ assert Ray3D((1, 1, 1), direction_ratio=[4, 4, 4]) == Ray3D(Point3D(1, 1, 1), Point3D(5, 5, 5))
+ assert Ray3D((1, 1, 1), direction_ratio=[1, 2, 3]) == Ray3D(Point3D(1, 1, 1), Point3D(2, 3, 4))
+ assert Ray3D((1, 1, 1), direction_ratio=[1, 1, 1]) == Ray3D(Point3D(1, 1, 1), Point3D(2, 2, 2))
+
+
+def test_issue_7814():
+ circle = Circle(Point(x, 0), y)
+ line = Line(Point(k, z), slope=0)
+ _s = sqrt((y - z)*(y + z))
+ assert line.intersection(circle) == [Point2D(x + _s, z), Point2D(x - _s, z)]
+
+
+def test_issue_2941():
+ def _check():
+ for f, g in cartes(*[(Line, Ray, Segment)] * 2):
+ l1 = f(a, b)
+ l2 = g(c, d)
+ assert l1.intersection(l2) == l2.intersection(l1)
+ # intersect at end point
+ c, d = (-2, -2), (-2, 0)
+ a, b = (0, 0), (1, 1)
+ _check()
+ # midline intersection
+ c, d = (-2, -3), (-2, 0)
+ _check()
+
+
+def test_parameter_value():
+ t = Symbol('t')
+ p1, p2 = Point(0, 1), Point(5, 6)
+ l = Line(p1, p2)
+ assert l.parameter_value((5, 6), t) == {t: 1}
+ raises(ValueError, lambda: l.parameter_value((0, 0), t))
+
+
+def test_bisectors():
+ r1 = Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))
+ r2 = Line3D(Point3D(0, 0, 0), Point3D(0, 1, 0))
+ bisections = r1.bisectors(r2)
+ assert bisections == [Line3D(Point3D(0, 0, 0), Point3D(1, 1, 0)),
+ Line3D(Point3D(0, 0, 0), Point3D(1, -1, 0))]
+ ans = [Line3D(Point3D(0, 0, 0), Point3D(1, 0, 1)),
+ Line3D(Point3D(0, 0, 0), Point3D(-1, 0, 1))]
+ l1 = (0, 0, 0), (0, 0, 1)
+ l2 = (0, 0), (1, 0)
+ for a, b in cartes((Line, Segment, Ray), repeat=2):
+ assert a(*l1).bisectors(b(*l2)) == ans
+
+
+def test_issue_8615():
+ a = Line3D(Point3D(6, 5, 0), Point3D(6, -6, 0))
+ b = Line3D(Point3D(6, -1, 19/10), Point3D(6, -1, 0))
+ assert a.intersection(b) == [Point3D(6, -1, 0)]
+
+
+def test_issue_12598():
+ r1 = Ray(Point(0, 1), Point(0.98, 0.79).n(2))
+ r2 = Ray(Point(0, 0), Point(0.71, 0.71).n(2))
+ assert str(r1.intersection(r2)[0]) == 'Point2D(0.82, 0.82)'
+ l1 = Line((0, 0), (1, 1))
+ l2 = Segment((-1, 1), (0, -1)).n(2)
+ assert str(l1.intersection(l2)[0]) == 'Point2D(-0.33, -0.33)'
+ l2 = Segment((-1, 1), (-1/2, 1/2)).n(2)
+ assert not l1.intersection(l2)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_parabola.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_parabola.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a683f26619952d93475aca9ebd3d47cfb3657a6
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_parabola.py
@@ -0,0 +1,143 @@
+from sympy.core.numbers import (Rational, oo)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.geometry.ellipse import (Circle, Ellipse)
+from sympy.geometry.line import (Line, Ray2D, Segment2D)
+from sympy.geometry.parabola import Parabola
+from sympy.geometry.point import (Point, Point2D)
+from sympy.testing.pytest import raises
+
+from sympy.abc import x, y
+
+def test_parabola_geom():
+ a, b = symbols('a b')
+ p1 = Point(0, 0)
+ p2 = Point(3, 7)
+ p3 = Point(0, 4)
+ p4 = Point(6, 0)
+ p5 = Point(a, a)
+ d1 = Line(Point(4, 0), Point(4, 9))
+ d2 = Line(Point(7, 6), Point(3, 6))
+ d3 = Line(Point(4, 0), slope=oo)
+ d4 = Line(Point(7, 6), slope=0)
+ d5 = Line(Point(b, a), slope=oo)
+ d6 = Line(Point(a, b), slope=0)
+
+ half = S.Half
+
+ pa1 = Parabola(None, d2)
+ pa2 = Parabola(directrix=d1)
+ pa3 = Parabola(p1, d1)
+ pa4 = Parabola(p2, d2)
+ pa5 = Parabola(p2, d4)
+ pa6 = Parabola(p3, d2)
+ pa7 = Parabola(p2, d1)
+ pa8 = Parabola(p4, d1)
+ pa9 = Parabola(p4, d3)
+ pa10 = Parabola(p5, d5)
+ pa11 = Parabola(p5, d6)
+ d = Line(Point(3, 7), Point(2, 9))
+ pa12 = Parabola(Point(7, 8), d)
+ pa12r = Parabola(Point(7, 8).reflect(d), d)
+
+ raises(ValueError, lambda:
+ Parabola(Point(7, 8, 9), Line(Point(6, 7), Point(7, 7))))
+ raises(ValueError, lambda:
+ Parabola(Point(0, 2), Line(Point(7, 2), Point(6, 2))))
+ raises(ValueError, lambda: Parabola(Point(7, 8), Point(3, 8)))
+
+ # Basic Stuff
+ assert pa1.focus == Point(0, 0)
+ assert pa1.ambient_dimension == S(2)
+ assert pa2 == pa3
+ assert pa4 != pa7
+ assert pa6 != pa7
+ assert pa6.focus == Point2D(0, 4)
+ assert pa6.focal_length == 1
+ assert pa6.p_parameter == -1
+ assert pa6.vertex == Point2D(0, 5)
+ assert pa6.eccentricity == 1
+ assert pa7.focus == Point2D(3, 7)
+ assert pa7.focal_length == half
+ assert pa7.p_parameter == -half
+ assert pa7.vertex == Point2D(7*half, 7)
+ assert pa4.focal_length == half
+ assert pa4.p_parameter == half
+ assert pa4.vertex == Point2D(3, 13*half)
+ assert pa8.focal_length == 1
+ assert pa8.p_parameter == 1
+ assert pa8.vertex == Point2D(5, 0)
+ assert pa4.focal_length == pa5.focal_length
+ assert pa4.p_parameter == pa5.p_parameter
+ assert pa4.vertex == pa5.vertex
+ assert pa4.equation() == pa5.equation()
+ assert pa8.focal_length == pa9.focal_length
+ assert pa8.p_parameter == pa9.p_parameter
+ assert pa8.vertex == pa9.vertex
+ assert pa8.equation() == pa9.equation()
+ assert pa10.focal_length == pa11.focal_length == sqrt((a - b) ** 2) / 2 # if a, b real == abs(a - b)/2
+ assert pa11.vertex == Point(*pa10.vertex[::-1]) == Point(a,
+ a - sqrt((a - b)**2)*sign(a - b)/2) # change axis x->y, y->x on pa10
+ aos = pa12.axis_of_symmetry
+ assert aos == Line(Point(7, 8), Point(5, 7))
+ assert pa12.directrix == Line(Point(3, 7), Point(2, 9))
+ assert pa12.directrix.angle_between(aos) == S.Pi/2
+ assert pa12.eccentricity == 1
+ assert pa12.equation(x, y) == (x - 7)**2 + (y - 8)**2 - (-2*x - y + 13)**2/5
+ assert pa12.focal_length == 9*sqrt(5)/10
+ assert pa12.focus == Point(7, 8)
+ assert pa12.p_parameter == 9*sqrt(5)/10
+ assert pa12.vertex == Point2D(S(26)/5, S(71)/10)
+ assert pa12r.focal_length == 9*sqrt(5)/10
+ assert pa12r.focus == Point(-S(1)/5, S(22)/5)
+ assert pa12r.p_parameter == -9*sqrt(5)/10
+ assert pa12r.vertex == Point(S(8)/5, S(53)/10)
+
+
+def test_parabola_intersection():
+ l1 = Line(Point(1, -2), Point(-1,-2))
+ l2 = Line(Point(1, 2), Point(-1,2))
+ l3 = Line(Point(1, 0), Point(-1,0))
+
+ p1 = Point(0,0)
+ p2 = Point(0, -2)
+ p3 = Point(120, -12)
+ parabola1 = Parabola(p1, l1)
+
+ # parabola with parabola
+ assert parabola1.intersection(parabola1) == [parabola1]
+ assert parabola1.intersection(Parabola(p1, l2)) == [Point2D(-2, 0), Point2D(2, 0)]
+ assert parabola1.intersection(Parabola(p2, l3)) == [Point2D(0, -1)]
+ assert parabola1.intersection(Parabola(Point(16, 0), l1)) == [Point2D(8, 15)]
+ assert parabola1.intersection(Parabola(Point(0, 16), l1)) == [Point2D(-6, 8), Point2D(6, 8)]
+ assert parabola1.intersection(Parabola(p3, l3)) == []
+ # parabola with point
+ assert parabola1.intersection(p1) == []
+ assert parabola1.intersection(Point2D(0, -1)) == [Point2D(0, -1)]
+ assert parabola1.intersection(Point2D(4, 3)) == [Point2D(4, 3)]
+ # parabola with line
+ assert parabola1.intersection(Line(Point2D(-7, 3), Point(12, 3))) == [Point2D(-4, 3), Point2D(4, 3)]
+ assert parabola1.intersection(Line(Point(-4, -1), Point(4, -1))) == [Point(0, -1)]
+ assert parabola1.intersection(Line(Point(2, 0), Point(0, -2))) == [Point2D(2, 0)]
+ raises(TypeError, lambda: parabola1.intersection(Line(Point(0, 0, 0), Point(1, 1, 1))))
+ # parabola with segment
+ assert parabola1.intersection(Segment2D((-4, -5), (4, 3))) == [Point2D(0, -1), Point2D(4, 3)]
+ assert parabola1.intersection(Segment2D((0, -5), (0, 6))) == [Point2D(0, -1)]
+ assert parabola1.intersection(Segment2D((-12, -65), (14, -68))) == []
+ # parabola with ray
+ assert parabola1.intersection(Ray2D((-4, -5), (4, 3))) == [Point2D(0, -1), Point2D(4, 3)]
+ assert parabola1.intersection(Ray2D((0, 7), (1, 14))) == [Point2D(14 + 2*sqrt(57), 105 + 14*sqrt(57))]
+ assert parabola1.intersection(Ray2D((0, 7), (0, 14))) == []
+ # parabola with ellipse/circle
+ assert parabola1.intersection(Circle(p1, 2)) == [Point2D(-2, 0), Point2D(2, 0)]
+ assert parabola1.intersection(Circle(p2, 1)) == [Point2D(0, -1)]
+ assert parabola1.intersection(Ellipse(p2, 2, 1)) == [Point2D(0, -1)]
+ assert parabola1.intersection(Ellipse(Point(0, 19), 5, 7)) == []
+ assert parabola1.intersection(Ellipse((0, 3), 12, 4)) == [
+ Point2D(0, -1),
+ Point2D(-4*sqrt(17)/3, Rational(59, 9)),
+ Point2D(4*sqrt(17)/3, Rational(59, 9))]
+ # parabola with unsupported type
+ raises(TypeError, lambda: parabola1.intersection(2))
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_plane.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_plane.py
new file mode 100644
index 0000000000000000000000000000000000000000..1010fce5c3bc68348eacee13f29c1d7588f17e39
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_plane.py
@@ -0,0 +1,268 @@
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (asin, cos, sin)
+from sympy.geometry import Line, Point, Ray, Segment, Point3D, Line3D, Ray3D, Segment3D, Plane, Circle
+from sympy.geometry.util import are_coplanar
+from sympy.testing.pytest import raises
+
+
+def test_plane():
+ x, y, z, u, v = symbols('x y z u v', real=True)
+ p1 = Point3D(0, 0, 0)
+ p2 = Point3D(1, 1, 1)
+ p3 = Point3D(1, 2, 3)
+ pl3 = Plane(p1, p2, p3)
+ pl4 = Plane(p1, normal_vector=(1, 1, 1))
+ pl4b = Plane(p1, p2)
+ pl5 = Plane(p3, normal_vector=(1, 2, 3))
+ pl6 = Plane(Point3D(2, 3, 7), normal_vector=(2, 2, 2))
+ pl7 = Plane(Point3D(1, -5, -6), normal_vector=(1, -2, 1))
+ pl8 = Plane(p1, normal_vector=(0, 0, 1))
+ pl9 = Plane(p1, normal_vector=(0, 12, 0))
+ pl10 = Plane(p1, normal_vector=(-2, 0, 0))
+ pl11 = Plane(p2, normal_vector=(0, 0, 1))
+ l1 = Line3D(Point3D(5, 0, 0), Point3D(1, -1, 1))
+ l2 = Line3D(Point3D(0, -2, 0), Point3D(3, 1, 1))
+ l3 = Line3D(Point3D(0, -1, 0), Point3D(5, -1, 9))
+
+ raises(ValueError, lambda: Plane(p1, p1, p1))
+
+ assert Plane(p1, p2, p3) != Plane(p1, p3, p2)
+ assert Plane(p1, p2, p3).is_coplanar(Plane(p1, p3, p2))
+ assert Plane(p1, p2, p3).is_coplanar(p1)
+ assert Plane(p1, p2, p3).is_coplanar(Circle(p1, 1)) is False
+ assert Plane(p1, normal_vector=(0, 0, 1)).is_coplanar(Circle(p1, 1))
+
+ assert pl3 == Plane(Point3D(0, 0, 0), normal_vector=(1, -2, 1))
+ assert pl3 != pl4
+ assert pl4 == pl4b
+ assert pl5 == Plane(Point3D(1, 2, 3), normal_vector=(1, 2, 3))
+
+ assert pl5.equation(x, y, z) == x + 2*y + 3*z - 14
+ assert pl3.equation(x, y, z) == x - 2*y + z
+
+ assert pl3.p1 == p1
+ assert pl4.p1 == p1
+ assert pl5.p1 == p3
+
+ assert pl4.normal_vector == (1, 1, 1)
+ assert pl5.normal_vector == (1, 2, 3)
+
+ assert p1 in pl3
+ assert p1 in pl4
+ assert p3 in pl5
+
+ assert pl3.projection(Point(0, 0)) == p1
+ p = pl3.projection(Point3D(1, 1, 0))
+ assert p == Point3D(Rational(7, 6), Rational(2, 3), Rational(1, 6))
+ assert p in pl3
+
+ l = pl3.projection_line(Line(Point(0, 0), Point(1, 1)))
+ assert l == Line3D(Point3D(0, 0, 0), Point3D(Rational(7, 6), Rational(2, 3), Rational(1, 6)))
+ assert l in pl3
+ # get a segment that does not intersect the plane which is also
+ # parallel to pl3's normal veector
+ t = Dummy()
+ r = pl3.random_point()
+ a = pl3.perpendicular_line(r).arbitrary_point(t)
+ s = Segment3D(a.subs(t, 1), a.subs(t, 2))
+ assert s.p1 not in pl3 and s.p2 not in pl3
+ assert pl3.projection_line(s).equals(r)
+ assert pl3.projection_line(Segment(Point(1, 0), Point(1, 1))) == \
+ Segment3D(Point3D(Rational(5, 6), Rational(1, 3), Rational(-1, 6)), Point3D(Rational(7, 6), Rational(2, 3), Rational(1, 6)))
+ assert pl6.projection_line(Ray(Point(1, 0), Point(1, 1))) == \
+ Ray3D(Point3D(Rational(14, 3), Rational(11, 3), Rational(11, 3)), Point3D(Rational(13, 3), Rational(13, 3), Rational(10, 3)))
+ assert pl3.perpendicular_line(r.args) == pl3.perpendicular_line(r)
+
+ assert pl3.is_parallel(pl6) is False
+ assert pl4.is_parallel(pl6)
+ assert pl3.is_parallel(Line(p1, p2))
+ assert pl6.is_parallel(l1) is False
+
+ assert pl3.is_perpendicular(pl6)
+ assert pl4.is_perpendicular(pl7)
+ assert pl6.is_perpendicular(pl7)
+ assert pl6.is_perpendicular(pl4) is False
+ assert pl6.is_perpendicular(l1) is False
+ assert pl6.is_perpendicular(Line((0, 0, 0), (1, 1, 1)))
+ assert pl6.is_perpendicular((1, 1)) is False
+
+ assert pl6.distance(pl6.arbitrary_point(u, v)) == 0
+ assert pl7.distance(pl7.arbitrary_point(u, v)) == 0
+ assert pl6.distance(pl6.arbitrary_point(t)) == 0
+ assert pl7.distance(pl7.arbitrary_point(t)) == 0
+ assert pl6.p1.distance(pl6.arbitrary_point(t)).simplify() == 1
+ assert pl7.p1.distance(pl7.arbitrary_point(t)).simplify() == 1
+ assert pl3.arbitrary_point(t) == Point3D(-sqrt(30)*sin(t)/30 + \
+ 2*sqrt(5)*cos(t)/5, sqrt(30)*sin(t)/15 + sqrt(5)*cos(t)/5, sqrt(30)*sin(t)/6)
+ assert pl3.arbitrary_point(u, v) == Point3D(2*u - v, u + 2*v, 5*v)
+
+ assert pl7.distance(Point3D(1, 3, 5)) == 5*sqrt(6)/6
+ assert pl6.distance(Point3D(0, 0, 0)) == 4*sqrt(3)
+ assert pl6.distance(pl6.p1) == 0
+ assert pl7.distance(pl6) == 0
+ assert pl7.distance(l1) == 0
+ assert pl6.distance(Segment3D(Point3D(2, 3, 1), Point3D(1, 3, 4))) == \
+ pl6.distance(Point3D(1, 3, 4)) == 4*sqrt(3)/3
+ assert pl6.distance(Segment3D(Point3D(1, 3, 4), Point3D(0, 3, 7))) == \
+ pl6.distance(Point3D(0, 3, 7)) == 2*sqrt(3)/3
+ assert pl6.distance(Segment3D(Point3D(0, 3, 7), Point3D(-1, 3, 10))) == 0
+ assert pl6.distance(Segment3D(Point3D(-1, 3, 10), Point3D(-2, 3, 13))) == 0
+ assert pl6.distance(Segment3D(Point3D(-2, 3, 13), Point3D(-3, 3, 16))) == \
+ pl6.distance(Point3D(-2, 3, 13)) == 2*sqrt(3)/3
+ assert pl6.distance(Plane(Point3D(5, 5, 5), normal_vector=(8, 8, 8))) == sqrt(3)
+ assert pl6.distance(Ray3D(Point3D(1, 3, 4), direction_ratio=[1, 0, -3])) == 4*sqrt(3)/3
+ assert pl6.distance(Ray3D(Point3D(2, 3, 1), direction_ratio=[-1, 0, 3])) == 0
+
+
+ assert pl6.angle_between(pl3) == pi/2
+ assert pl6.angle_between(pl6) == 0
+ assert pl6.angle_between(pl4) == 0
+ assert pl7.angle_between(Line3D(Point3D(2, 3, 5), Point3D(2, 4, 6))) == \
+ -asin(sqrt(3)/6)
+ assert pl6.angle_between(Ray3D(Point3D(2, 4, 1), Point3D(6, 5, 3))) == \
+ asin(sqrt(7)/3)
+ assert pl7.angle_between(Segment3D(Point3D(5, 6, 1), Point3D(1, 2, 4))) == \
+ asin(7*sqrt(246)/246)
+
+ assert are_coplanar(l1, l2, l3) is False
+ assert are_coplanar(l1) is False
+ assert are_coplanar(Point3D(2, 7, 2), Point3D(0, 0, 2),
+ Point3D(1, 1, 2), Point3D(1, 2, 2))
+ assert are_coplanar(Plane(p1, p2, p3), Plane(p1, p3, p2))
+ assert Plane.are_concurrent(pl3, pl4, pl5) is False
+ assert Plane.are_concurrent(pl6) is False
+ raises(ValueError, lambda: Plane.are_concurrent(Point3D(0, 0, 0)))
+ raises(ValueError, lambda: Plane((1, 2, 3), normal_vector=(0, 0, 0)))
+
+ assert pl3.parallel_plane(Point3D(1, 2, 5)) == Plane(Point3D(1, 2, 5), \
+ normal_vector=(1, -2, 1))
+
+ # perpendicular_plane
+ p = Plane((0, 0, 0), (1, 0, 0))
+ # default
+ assert p.perpendicular_plane() == Plane(Point3D(0, 0, 0), (0, 1, 0))
+ # 1 pt
+ assert p.perpendicular_plane(Point3D(1, 0, 1)) == \
+ Plane(Point3D(1, 0, 1), (0, 1, 0))
+ # pts as tuples
+ assert p.perpendicular_plane((1, 0, 1), (1, 1, 1)) == \
+ Plane(Point3D(1, 0, 1), (0, 0, -1))
+ # more than two planes
+ raises(ValueError, lambda: p.perpendicular_plane((1, 0, 1), (1, 1, 1), (1, 1, 0)))
+
+ a, b = Point3D(0, 0, 0), Point3D(0, 1, 0)
+ Z = (0, 0, 1)
+ p = Plane(a, normal_vector=Z)
+ # case 4
+ assert p.perpendicular_plane(a, b) == Plane(a, (1, 0, 0))
+ n = Point3D(*Z)
+ # case 1
+ assert p.perpendicular_plane(a, n) == Plane(a, (-1, 0, 0))
+ # case 2
+ assert Plane(a, normal_vector=b.args).perpendicular_plane(a, a + b) == \
+ Plane(Point3D(0, 0, 0), (1, 0, 0))
+ # case 1&3
+ assert Plane(b, normal_vector=Z).perpendicular_plane(b, b + n) == \
+ Plane(Point3D(0, 1, 0), (-1, 0, 0))
+ # case 2&3
+ assert Plane(b, normal_vector=b.args).perpendicular_plane(n, n + b) == \
+ Plane(Point3D(0, 0, 1), (1, 0, 0))
+
+ p = Plane(a, normal_vector=(0, 0, 1))
+ assert p.perpendicular_plane() == Plane(a, normal_vector=(1, 0, 0))
+
+ assert pl6.intersection(pl6) == [pl6]
+ assert pl4.intersection(pl4.p1) == [pl4.p1]
+ assert pl3.intersection(pl6) == [
+ Line3D(Point3D(8, 4, 0), Point3D(2, 4, 6))]
+ assert pl3.intersection(Line3D(Point3D(1,2,4), Point3D(4,4,2))) == [
+ Point3D(2, Rational(8, 3), Rational(10, 3))]
+ assert pl3.intersection(Plane(Point3D(6, 0, 0), normal_vector=(2, -5, 3))
+ ) == [Line3D(Point3D(-24, -12, 0), Point3D(-25, -13, -1))]
+ assert pl6.intersection(Ray3D(Point3D(2, 3, 1), Point3D(1, 3, 4))) == [
+ Point3D(-1, 3, 10)]
+ assert pl6.intersection(Segment3D(Point3D(2, 3, 1), Point3D(1, 3, 4))) == []
+ assert pl7.intersection(Line(Point(2, 3), Point(4, 2))) == [
+ Point3D(Rational(13, 2), Rational(3, 4), 0)]
+ r = Ray(Point(2, 3), Point(4, 2))
+ assert Plane((1,2,0), normal_vector=(0,0,1)).intersection(r) == [
+ Ray3D(Point(2, 3), Point(4, 2))]
+ assert pl9.intersection(pl8) == [Line3D(Point3D(0, 0, 0), Point3D(12, 0, 0))]
+ assert pl10.intersection(pl11) == [Line3D(Point3D(0, 0, 1), Point3D(0, 2, 1))]
+ assert pl4.intersection(pl8) == [Line3D(Point3D(0, 0, 0), Point3D(1, -1, 0))]
+ assert pl11.intersection(pl8) == []
+ assert pl9.intersection(pl11) == [Line3D(Point3D(0, 0, 1), Point3D(12, 0, 1))]
+ assert pl9.intersection(pl4) == [Line3D(Point3D(0, 0, 0), Point3D(12, 0, -12))]
+ assert pl3.random_point() in pl3
+ assert pl3.random_point(seed=1) in pl3
+
+ # test geometrical entity using equals
+ assert pl4.intersection(pl4.p1)[0].equals(pl4.p1)
+ assert pl3.intersection(pl6)[0].equals(Line3D(Point3D(8, 4, 0), Point3D(2, 4, 6)))
+ pl8 = Plane((1, 2, 0), normal_vector=(0, 0, 1))
+ assert pl8.intersection(Line3D(p1, (1, 12, 0)))[0].equals(Line((0, 0, 0), (0.1, 1.2, 0)))
+ assert pl8.intersection(Ray3D(p1, (1, 12, 0)))[0].equals(Ray((0, 0, 0), (1, 12, 0)))
+ assert pl8.intersection(Segment3D(p1, (21, 1, 0)))[0].equals(Segment3D(p1, (21, 1, 0)))
+ assert pl8.intersection(Plane(p1, normal_vector=(0, 0, 112)))[0].equals(pl8)
+ assert pl8.intersection(Plane(p1, normal_vector=(0, 12, 0)))[0].equals(
+ Line3D(p1, direction_ratio=(112 * pi, 0, 0)))
+ assert pl8.intersection(Plane(p1, normal_vector=(11, 0, 1)))[0].equals(
+ Line3D(p1, direction_ratio=(0, -11, 0)))
+ assert pl8.intersection(Plane(p1, normal_vector=(1, 0, 11)))[0].equals(
+ Line3D(p1, direction_ratio=(0, 11, 0)))
+ assert pl8.intersection(Plane(p1, normal_vector=(-1, -1, -11)))[0].equals(
+ Line3D(p1, direction_ratio=(1, -1, 0)))
+ assert pl3.random_point() in pl3
+ assert len(pl8.intersection(Ray3D(Point3D(0, 2, 3), Point3D(1, 0, 3)))) == 0
+ # check if two plane are equals
+ assert pl6.intersection(pl6)[0].equals(pl6)
+ assert pl8.equals(Plane(p1, normal_vector=(0, 12, 0))) is False
+ assert pl8.equals(pl8)
+ assert pl8.equals(Plane(p1, normal_vector=(0, 0, -12)))
+ assert pl8.equals(Plane(p1, normal_vector=(0, 0, -12*sqrt(3))))
+ assert pl8.equals(p1) is False
+
+ # issue 8570
+ l2 = Line3D(Point3D(Rational(50000004459633, 5000000000000),
+ Rational(-891926590718643, 1000000000000000),
+ Rational(231800966893633, 100000000000000)),
+ Point3D(Rational(50000004459633, 50000000000000),
+ Rational(-222981647679771, 250000000000000),
+ Rational(231800966893633, 100000000000000)))
+
+ p2 = Plane(Point3D(Rational(402775636372767, 100000000000000),
+ Rational(-97224357654973, 100000000000000),
+ Rational(216793600814789, 100000000000000)),
+ (-S('9.00000087501922'), -S('4.81170658872543e-13'),
+ S('0.0')))
+
+ assert str([i.n(2) for i in p2.intersection(l2)]) == \
+ '[Point3D(4.0, -0.89, 2.3)]'
+
+
+def test_dimension_normalization():
+ A = Plane(Point3D(1, 1, 2), normal_vector=(1, 1, 1))
+ b = Point(1, 1)
+ assert A.projection(b) == Point(Rational(5, 3), Rational(5, 3), Rational(2, 3))
+
+ a, b = Point(0, 0), Point3D(0, 1)
+ Z = (0, 0, 1)
+ p = Plane(a, normal_vector=Z)
+ assert p.perpendicular_plane(a, b) == Plane(Point3D(0, 0, 0), (1, 0, 0))
+ assert Plane((1, 2, 1), (2, 1, 0), (3, 1, 2)
+ ).intersection((2, 1)) == [Point(2, 1, 0)]
+
+
+def test_parameter_value():
+ t, u, v = symbols("t, u v")
+ p1, p2, p3 = Point(0, 0, 0), Point(0, 0, 1), Point(0, 1, 0)
+ p = Plane(p1, p2, p3)
+ assert p.parameter_value((0, -3, 2), t) == {t: asin(2*sqrt(13)/13)}
+ assert p.parameter_value((0, -3, 2), u, v) == {u: 3, v: 2}
+ assert p.parameter_value(p1, t) == p1
+ raises(ValueError, lambda: p.parameter_value((1, 0, 0), t))
+ raises(ValueError, lambda: p.parameter_value(Line(Point(0, 0), Point(1, 1)), t))
+ raises(ValueError, lambda: p.parameter_value((0, -3, 2), t, 1))
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_point.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_point.py
new file mode 100644
index 0000000000000000000000000000000000000000..abe63874a84ea9426c31bdd517b9282b779cc52b
--- /dev/null
+++ b/llmeval-env/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/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_polygon.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_polygon.py
new file mode 100644
index 0000000000000000000000000000000000000000..08e0be1706ba3e3ce4d65c1024664ab96b05adc9
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_polygon.py
@@ -0,0 +1,664 @@
+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
+
+
+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)
+
+ 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"))
+
+ #
+ # 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/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_util.py b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8440beadcc75d8c2ac2065519061e519765ec3a
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/geometry/tests/test_util.py
@@ -0,0 +1,151 @@
+from sympy.core.function import (Derivative, Function)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions import exp, cos, sin, tan, cosh, sinh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.geometry import Point, Point2D, Line, Polygon, Segment, convex_hull,\
+ intersection, centroid, Point3D, Line3D
+from sympy.geometry.util import idiff, closest_points, farthest_points, _ordered_points, are_coplanar
+from sympy.solvers.solvers import solve
+from sympy.testing.pytest import raises
+
+
+def test_idiff():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ t = Symbol('t', real=True)
+ f = Function('f')
+ g = Function('g')
+ # the use of idiff in ellipse also provides coverage
+ circ = x**2 + y**2 - 4
+ ans = -3*x*(x**2/y**2 + 1)/y**3
+ assert ans == idiff(circ, y, x, 3), idiff(circ, y, x, 3)
+ assert ans == idiff(circ, [y], x, 3)
+ assert idiff(circ, y, x, 3) == ans
+ explicit = 12*x/sqrt(-x**2 + 4)**5
+ assert ans.subs(y, solve(circ, y)[0]).equals(explicit)
+ assert True in [sol.diff(x, 3).equals(explicit) for sol in solve(circ, y)]
+ assert idiff(x + t + y, [y, t], x) == -Derivative(t, x) - 1
+ assert idiff(f(x) * exp(f(x)) - x * exp(x), f(x), x) == (x + 1)*exp(x)*exp(-f(x))/(f(x) + 1)
+ assert idiff(f(x) - y * exp(x), [f(x), y], x) == (y + Derivative(y, x))*exp(x)
+ assert idiff(f(x) - y * exp(x), [y, f(x)], x) == -y + Derivative(f(x), x)*exp(-x)
+ assert idiff(f(x) - g(x), [f(x), g(x)], x) == Derivative(g(x), x)
+ # this should be fast
+ fxy = y - (-10*(-sin(x) + 1/x)**2 + tan(x)**2 + 2*cosh(x/10))
+ assert idiff(fxy, y, x) == -20*sin(x)*cos(x) + 2*tan(x)**3 + \
+ 2*tan(x) + sinh(x/10)/5 + 20*cos(x)/x - 20*sin(x)/x**2 + 20/x**3
+
+
+def test_intersection():
+ assert intersection(Point(0, 0)) == []
+ raises(TypeError, lambda: intersection(Point(0, 0), 3))
+ assert intersection(
+ Segment((0, 0), (2, 0)),
+ Segment((-1, 0), (1, 0)),
+ Line((0, 0), (0, 1)), pairwise=True) == [
+ Point(0, 0), Segment((0, 0), (1, 0))]
+ assert intersection(
+ Line((0, 0), (0, 1)),
+ Segment((0, 0), (2, 0)),
+ Segment((-1, 0), (1, 0)), pairwise=True) == [
+ Point(0, 0), Segment((0, 0), (1, 0))]
+ assert intersection(
+ Line((0, 0), (0, 1)),
+ Segment((0, 0), (2, 0)),
+ Segment((-1, 0), (1, 0)),
+ Line((0, 0), slope=1), pairwise=True) == [
+ Point(0, 0), Segment((0, 0), (1, 0))]
+
+
+def test_convex_hull():
+ raises(TypeError, lambda: convex_hull(Point(0, 0), 3))
+ points = [(1, -1), (1, -2), (3, -1), (-5, -2), (15, -4)]
+ assert convex_hull(*points, **{"polygon": False}) == (
+ [Point2D(-5, -2), Point2D(1, -1), Point2D(3, -1), Point2D(15, -4)],
+ [Point2D(-5, -2), Point2D(15, -4)])
+
+
+def test_centroid():
+ p = Polygon((0, 0), (10, 0), (10, 10))
+ q = p.translate(0, 20)
+ assert centroid(p, q) == Point(20, 40)/3
+ p = Segment((0, 0), (2, 0))
+ q = Segment((0, 0), (2, 2))
+ assert centroid(p, q) == Point(1, -sqrt(2) + 2)
+ assert centroid(Point(0, 0), Point(2, 0)) == Point(2, 0)/2
+ assert centroid(Point(0, 0), Point(0, 0), Point(2, 0)) == Point(2, 0)/3
+
+
+def test_farthest_points_closest_points():
+ from sympy.core.random import randint
+ from sympy.utilities.iterables import subsets
+
+ for how in (min, max):
+ if how == min:
+ func = closest_points
+ else:
+ func = farthest_points
+
+ raises(ValueError, lambda: func(Point2D(0, 0), Point2D(0, 0)))
+
+ # 3rd pt dx is close and pt is closer to 1st pt
+ p1 = [Point2D(0, 0), Point2D(3, 0), Point2D(1, 1)]
+ # 3rd pt dx is close and pt is closer to 2nd pt
+ p2 = [Point2D(0, 0), Point2D(3, 0), Point2D(2, 1)]
+ # 3rd pt dx is close and but pt is not closer
+ p3 = [Point2D(0, 0), Point2D(3, 0), Point2D(1, 10)]
+ # 3rd pt dx is not closer and it's closer to 2nd pt
+ p4 = [Point2D(0, 0), Point2D(3, 0), Point2D(4, 0)]
+ # 3rd pt dx is not closer and it's closer to 1st pt
+ p5 = [Point2D(0, 0), Point2D(3, 0), Point2D(-1, 0)]
+ # duplicate point doesn't affect outcome
+ dup = [Point2D(0, 0), Point2D(3, 0), Point2D(3, 0), Point2D(-1, 0)]
+ # symbolic
+ x = Symbol('x', positive=True)
+ s = [Point2D(a) for a in ((x, 1), (x + 3, 2), (x + 2, 2))]
+
+ for points in (p1, p2, p3, p4, p5, dup, s):
+ d = how(i.distance(j) for i, j in subsets(set(points), 2))
+ ans = a, b = list(func(*points))[0]
+ assert a.distance(b) == d
+ assert ans == _ordered_points(ans)
+
+ # if the following ever fails, the above tests were not sufficient
+ # and the logical error in the routine should be fixed
+ points = set()
+ while len(points) != 7:
+ points.add(Point2D(randint(1, 100), randint(1, 100)))
+ points = list(points)
+ d = how(i.distance(j) for i, j in subsets(points, 2))
+ ans = a, b = list(func(*points))[0]
+ assert a.distance(b) == d
+ assert ans == _ordered_points(ans)
+
+ # equidistant points
+ a, b, c = (
+ Point2D(0, 0), Point2D(1, 0), Point2D(S.Half, sqrt(3)/2))
+ ans = {_ordered_points((i, j))
+ for i, j in subsets((a, b, c), 2)}
+ assert closest_points(b, c, a) == ans
+ assert farthest_points(b, c, a) == ans
+
+ # unique to farthest
+ points = [(1, 1), (1, 2), (3, 1), (-5, 2), (15, 4)]
+ assert farthest_points(*points) == {
+ (Point2D(-5, 2), Point2D(15, 4))}
+ points = [(1, -1), (1, -2), (3, -1), (-5, -2), (15, -4)]
+ assert farthest_points(*points) == {
+ (Point2D(-5, -2), Point2D(15, -4))}
+ assert farthest_points((1, 1), (0, 0)) == {
+ (Point2D(0, 0), Point2D(1, 1))}
+ raises(ValueError, lambda: farthest_points((1, 1)))
+
+
+def test_are_coplanar():
+ a = Line3D(Point3D(5, 0, 0), Point3D(1, -1, 1))
+ b = Line3D(Point3D(0, -2, 0), Point3D(3, 1, 1))
+ c = Line3D(Point3D(0, -1, 0), Point3D(5, -1, 9))
+ d = Line(Point2D(0, 3), Point2D(1, 5))
+
+ assert are_coplanar(a, b, c) == False
+ assert are_coplanar(a, d) == False
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/__init__.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8e59192bf60ca545ddd1333ab813ce20ef43074
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/__init__.py
@@ -0,0 +1,71 @@
+"""A module for solving all kinds of equations.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers import solve
+ >>> from sympy.abc import x
+ >>> solve(x**5+5*x**4+10*x**3+10*x**2+5*x+1,x)
+ [-1]
+"""
+from sympy.core.assumptions import check_assumptions, failing_assumptions
+
+from .solvers import solve, solve_linear_system, solve_linear_system_LU, \
+ solve_undetermined_coeffs, nsolve, solve_linear, checksol, \
+ det_quick, inv_quick
+
+from .diophantine import diophantine
+
+from .recurr import rsolve, rsolve_poly, rsolve_ratio, rsolve_hyper
+
+from .ode import checkodesol, classify_ode, dsolve, \
+ homogeneous_order
+
+from .polysys import solve_poly_system, solve_triangulated
+
+from .pde import pde_separate, pde_separate_add, pde_separate_mul, \
+ pdsolve, classify_pde, checkpdesol
+
+from .deutils import ode_order
+
+from .inequalities import reduce_inequalities, reduce_abs_inequality, \
+ reduce_abs_inequalities, solve_poly_inequality, solve_rational_inequalities, solve_univariate_inequality
+
+from .decompogen import decompogen
+
+from .solveset import solveset, linsolve, linear_eq_to_matrix, nonlinsolve, substitution
+
+# This is here instead of sympy/sets/__init__.py to avoid circular import issues
+from ..core.singleton import S
+Complexes = S.Complexes
+
+__all__ = [
+ 'solve', 'solve_linear_system', 'solve_linear_system_LU',
+ 'solve_undetermined_coeffs', 'nsolve', 'solve_linear', 'checksol',
+ 'det_quick', 'inv_quick', 'check_assumptions', 'failing_assumptions',
+
+ 'diophantine',
+
+ 'rsolve', 'rsolve_poly', 'rsolve_ratio', 'rsolve_hyper',
+
+ 'checkodesol', 'classify_ode', 'dsolve', 'homogeneous_order',
+
+ 'solve_poly_system', 'solve_triangulated',
+
+ 'pde_separate', 'pde_separate_add', 'pde_separate_mul', 'pdsolve',
+ 'classify_pde', 'checkpdesol',
+
+ 'ode_order',
+
+ 'reduce_inequalities', 'reduce_abs_inequality', 'reduce_abs_inequalities',
+ 'solve_poly_inequality', 'solve_rational_inequalities',
+ 'solve_univariate_inequality',
+
+ 'decompogen',
+
+ 'solveset', 'linsolve', 'linear_eq_to_matrix', 'nonlinsolve',
+ 'substitution',
+
+ # This is here instead of sympy/sets/__init__.py to avoid circular import issues
+ 'Complexes',
+]
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/benchmarks/__init__.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/benchmarks/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/benchmarks/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/benchmarks/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e7498b3096c0fc071cf6ed833869040019f243bf
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/benchmarks/__pycache__/__init__.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/benchmarks/__pycache__/bench_solvers.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/benchmarks/__pycache__/bench_solvers.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..98759616dcffd3eb664c72a814457be6ce4d7c52
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/benchmarks/__pycache__/bench_solvers.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/benchmarks/bench_solvers.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/benchmarks/bench_solvers.py
new file mode 100644
index 0000000000000000000000000000000000000000..d18102873f7efcde1d111e0e8eca12e208f94663
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/benchmarks/bench_solvers.py
@@ -0,0 +1,12 @@
+from sympy.core.symbol import Symbol
+from sympy.matrices.dense import (eye, zeros)
+from sympy.solvers.solvers import solve_linear_system
+
+N = 8
+M = zeros(N, N + 1)
+M[:, :N] = eye(N)
+S = [Symbol('A%i' % i) for i in range(N)]
+
+
+def timeit_linsolve_trivial():
+ solve_linear_system(M, *S)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/bivariate.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/bivariate.py
new file mode 100644
index 0000000000000000000000000000000000000000..eec3df246e62b7f44de90296fb4987ada3887aae
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/bivariate.py
@@ -0,0 +1,509 @@
+from sympy.core.add import Add
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import expand_log, _mexpand
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy
+from sympy.functions.elementary.exponential import (LambertW, exp, log)
+from sympy.functions.elementary.miscellaneous import root
+from sympy.polys.polyroots import roots
+from sympy.polys.polytools import Poly, factor
+from sympy.simplify.simplify import separatevars
+from sympy.simplify.radsimp import collect
+from sympy.simplify.simplify import powsimp
+from sympy.solvers.solvers import solve, _invert
+from sympy.utilities.iterables import uniq
+
+
+def _filtered_gens(poly, symbol):
+ """process the generators of ``poly``, returning the set of generators that
+ have ``symbol``. If there are two generators that are inverses of each other,
+ prefer the one that has no denominator.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.bivariate import _filtered_gens
+ >>> from sympy import Poly, exp
+ >>> from sympy.abc import x
+ >>> _filtered_gens(Poly(x + 1/x + exp(x)), x)
+ {x, exp(x)}
+
+ """
+ # TODO it would be good to pick the smallest divisible power
+ # instead of the base for something like x**4 + x**2 -->
+ # return x**2 not x
+ gens = {g for g in poly.gens if symbol in g.free_symbols}
+ for g in list(gens):
+ ag = 1/g
+ if g in gens and ag in gens:
+ if ag.as_numer_denom()[1] is not S.One:
+ g = ag
+ gens.remove(g)
+ return gens
+
+
+def _mostfunc(lhs, func, X=None):
+ """Returns the term in lhs which contains the most of the
+ func-type things e.g. log(log(x)) wins over log(x) if both terms appear.
+
+ ``func`` can be a function (exp, log, etc...) or any other SymPy object,
+ like Pow.
+
+ If ``X`` is not ``None``, then the function returns the term composed with the
+ most ``func`` having the specified variable.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.bivariate import _mostfunc
+ >>> from sympy import exp
+ >>> from sympy.abc import x, y
+ >>> _mostfunc(exp(x) + exp(exp(x) + 2), exp)
+ exp(exp(x) + 2)
+ >>> _mostfunc(exp(x) + exp(exp(y) + 2), exp)
+ exp(exp(y) + 2)
+ >>> _mostfunc(exp(x) + exp(exp(y) + 2), exp, x)
+ exp(x)
+ >>> _mostfunc(x, exp, x) is None
+ True
+ >>> _mostfunc(exp(x) + exp(x*y), exp, x)
+ exp(x)
+ """
+ fterms = [tmp for tmp in lhs.atoms(func) if (not X or
+ X.is_Symbol and X in tmp.free_symbols or
+ not X.is_Symbol and tmp.has(X))]
+ if len(fterms) == 1:
+ return fterms[0]
+ elif fterms:
+ return max(list(ordered(fterms)), key=lambda x: x.count(func))
+ return None
+
+
+def _linab(arg, symbol):
+ """Return ``a, b, X`` assuming ``arg`` can be written as ``a*X + b``
+ where ``X`` is a symbol-dependent factor and ``a`` and ``b`` are
+ independent of ``symbol``.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.bivariate import _linab
+ >>> from sympy.abc import x, y
+ >>> from sympy import exp, S
+ >>> _linab(S(2), x)
+ (2, 0, 1)
+ >>> _linab(2*x, x)
+ (2, 0, x)
+ >>> _linab(y + y*x + 2*x, x)
+ (y + 2, y, x)
+ >>> _linab(3 + 2*exp(x), x)
+ (2, 3, exp(x))
+ """
+ arg = factor_terms(arg.expand())
+ ind, dep = arg.as_independent(symbol)
+ if arg.is_Mul and dep.is_Add:
+ a, b, x = _linab(dep, symbol)
+ return ind*a, ind*b, x
+ if not arg.is_Add:
+ b = 0
+ a, x = ind, dep
+ else:
+ b = ind
+ a, x = separatevars(dep).as_independent(symbol, as_Add=False)
+ if x.could_extract_minus_sign():
+ a = -a
+ x = -x
+ return a, b, x
+
+
+def _lambert(eq, x):
+ """
+ Given an expression assumed to be in the form
+ ``F(X, a..f) = a*log(b*X + c) + d*X + f = 0``
+ where X = g(x) and x = g^-1(X), return the Lambert solution,
+ ``x = g^-1(-c/b + (a/d)*W(d/(a*b)*exp(c*d/a/b)*exp(-f/a)))``.
+ """
+ eq = _mexpand(expand_log(eq))
+ mainlog = _mostfunc(eq, log, x)
+ if not mainlog:
+ return [] # violated assumptions
+ other = eq.subs(mainlog, 0)
+ if isinstance(-other, log):
+ eq = (eq - other).subs(mainlog, mainlog.args[0])
+ mainlog = mainlog.args[0]
+ if not isinstance(mainlog, log):
+ return [] # violated assumptions
+ other = -(-other).args[0]
+ eq += other
+ if x not in other.free_symbols:
+ return [] # violated assumptions
+ d, f, X2 = _linab(other, x)
+ logterm = collect(eq - other, mainlog)
+ a = logterm.as_coefficient(mainlog)
+ if a is None or x in a.free_symbols:
+ return [] # violated assumptions
+ logarg = mainlog.args[0]
+ b, c, X1 = _linab(logarg, x)
+ if X1 != X2:
+ return [] # violated assumptions
+
+ # invert the generator X1 so we have x(u)
+ u = Dummy('rhs')
+ xusolns = solve(X1 - u, x)
+
+ # There are infinitely many branches for LambertW
+ # but only branches for k = -1 and 0 might be real. The k = 0
+ # branch is real and the k = -1 branch is real if the LambertW argumen
+ # in in range [-1/e, 0]. Since `solve` does not return infinite
+ # solutions we will only include the -1 branch if it tests as real.
+ # Otherwise, inclusion of any LambertW in the solution indicates to
+ # the user that there are imaginary solutions corresponding to
+ # different k values.
+ lambert_real_branches = [-1, 0]
+ sol = []
+
+ # solution of the given Lambert equation is like
+ # sol = -c/b + (a/d)*LambertW(arg, k),
+ # where arg = d/(a*b)*exp((c*d-b*f)/a/b) and k in lambert_real_branches.
+ # Instead of considering the single arg, `d/(a*b)*exp((c*d-b*f)/a/b)`,
+ # the individual `p` roots obtained when writing `exp((c*d-b*f)/a/b)`
+ # as `exp(A/p) = exp(A)**(1/p)`, where `p` is an Integer, are used.
+
+ # calculating args for LambertW
+ num, den = ((c*d-b*f)/a/b).as_numer_denom()
+ p, den = den.as_coeff_Mul()
+ e = exp(num/den)
+ t = Dummy('t')
+ args = [d/(a*b)*t for t in roots(t**p - e, t).keys()]
+
+ # calculating solutions from args
+ for arg in args:
+ for k in lambert_real_branches:
+ w = LambertW(arg, k)
+ if k and not w.is_real:
+ continue
+ rhs = -c/b + (a/d)*w
+
+ sol.extend(xu.subs(u, rhs) for xu in xusolns)
+ return sol
+
+
+def _solve_lambert(f, symbol, gens):
+ """Return solution to ``f`` if it is a Lambert-type expression
+ else raise NotImplementedError.
+
+ For ``f(X, a..f) = a*log(b*X + c) + d*X - f = 0`` the solution
+ for ``X`` is ``X = -c/b + (a/d)*W(d/(a*b)*exp(c*d/a/b)*exp(f/a))``.
+ There are a variety of forms for `f(X, a..f)` as enumerated below:
+
+ 1a1)
+ if B**B = R for R not in [0, 1] (since those cases would already
+ be solved before getting here) then log of both sides gives
+ log(B) + log(log(B)) = log(log(R)) and
+ X = log(B), a = 1, b = 1, c = 0, d = 1, f = log(log(R))
+ 1a2)
+ if B*(b*log(B) + c)**a = R then log of both sides gives
+ log(B) + a*log(b*log(B) + c) = log(R) and
+ X = log(B), d=1, f=log(R)
+ 1b)
+ if a*log(b*B + c) + d*B = R and
+ X = B, f = R
+ 2a)
+ if (b*B + c)*exp(d*B + g) = R then log of both sides gives
+ log(b*B + c) + d*B + g = log(R) and
+ X = B, a = 1, f = log(R) - g
+ 2b)
+ if g*exp(d*B + h) - b*B = c then the log form is
+ log(g) + d*B + h - log(b*B + c) = 0 and
+ X = B, a = -1, f = -h - log(g)
+ 3)
+ if d*p**(a*B + g) - b*B = c then the log form is
+ log(d) + (a*B + g)*log(p) - log(b*B + c) = 0 and
+ X = B, a = -1, d = a*log(p), f = -log(d) - g*log(p)
+ """
+
+ def _solve_even_degree_expr(expr, t, symbol):
+ """Return the unique solutions of equations derived from
+ ``expr`` by replacing ``t`` with ``+/- symbol``.
+
+ Parameters
+ ==========
+
+ expr : Expr
+ The expression which includes a dummy variable t to be
+ replaced with +symbol and -symbol.
+
+ symbol : Symbol
+ The symbol for which a solution is being sought.
+
+ Returns
+ =======
+
+ List of unique solution of the two equations generated by
+ replacing ``t`` with positive and negative ``symbol``.
+
+ Notes
+ =====
+
+ If ``expr = 2*log(t) + x/2` then solutions for
+ ``2*log(x) + x/2 = 0`` and ``2*log(-x) + x/2 = 0`` are
+ returned by this function. Though this may seem
+ counter-intuitive, one must note that the ``expr`` being
+ solved here has been derived from a different expression. For
+ an expression like ``eq = x**2*g(x) = 1``, if we take the
+ log of both sides we obtain ``log(x**2) + log(g(x)) = 0``. If
+ x is positive then this simplifies to
+ ``2*log(x) + log(g(x)) = 0``; the Lambert-solving routines will
+ return solutions for this, but we must also consider the
+ solutions for ``2*log(-x) + log(g(x))`` since those must also
+ be a solution of ``eq`` which has the same value when the ``x``
+ in ``x**2`` is negated. If `g(x)` does not have even powers of
+ symbol then we do not want to replace the ``x`` there with
+ ``-x``. So the role of the ``t`` in the expression received by
+ this function is to mark where ``+/-x`` should be inserted
+ before obtaining the Lambert solutions.
+
+ """
+ nlhs, plhs = [
+ expr.xreplace({t: sgn*symbol}) for sgn in (-1, 1)]
+ sols = _solve_lambert(nlhs, symbol, gens)
+ if plhs != nlhs:
+ sols.extend(_solve_lambert(plhs, symbol, gens))
+ # uniq is needed for a case like
+ # 2*log(t) - log(-z**2) + log(z + log(x) + log(z))
+ # where substituting t with +/-x gives all the same solution;
+ # uniq, rather than list(set()), is used to maintain canonical
+ # order
+ return list(uniq(sols))
+
+ nrhs, lhs = f.as_independent(symbol, as_Add=True)
+ rhs = -nrhs
+
+ lamcheck = [tmp for tmp in gens
+ if (tmp.func in [exp, log] or
+ (tmp.is_Pow and symbol in tmp.exp.free_symbols))]
+ if not lamcheck:
+ raise NotImplementedError()
+
+ if lhs.is_Add or lhs.is_Mul:
+ # replacing all even_degrees of symbol with dummy variable t
+ # since these will need special handling; non-Add/Mul do not
+ # need this handling
+ t = Dummy('t', **symbol.assumptions0)
+ lhs = lhs.replace(
+ lambda i: # find symbol**even
+ i.is_Pow and i.base == symbol and i.exp.is_even,
+ lambda i: # replace t**even
+ t**i.exp)
+
+ if lhs.is_Add and lhs.has(t):
+ t_indep = lhs.subs(t, 0)
+ t_term = lhs - t_indep
+ _rhs = rhs - t_indep
+ if not t_term.is_Add and _rhs and not (
+ t_term.has(S.ComplexInfinity, S.NaN)):
+ eq = expand_log(log(t_term) - log(_rhs))
+ return _solve_even_degree_expr(eq, t, symbol)
+ elif lhs.is_Mul and rhs:
+ # this needs to happen whether t is present or not
+ lhs = expand_log(log(lhs), force=True)
+ rhs = log(rhs)
+ if lhs.has(t) and lhs.is_Add:
+ # it expanded from Mul to Add
+ eq = lhs - rhs
+ return _solve_even_degree_expr(eq, t, symbol)
+
+ # restore symbol in lhs
+ lhs = lhs.xreplace({t: symbol})
+
+ lhs = powsimp(factor(lhs, deep=True))
+
+ # make sure we have inverted as completely as possible
+ r = Dummy()
+ i, lhs = _invert(lhs - r, symbol)
+ rhs = i.xreplace({r: rhs})
+
+ # For the first forms:
+ #
+ # 1a1) B**B = R will arrive here as B*log(B) = log(R)
+ # lhs is Mul so take log of both sides:
+ # log(B) + log(log(B)) = log(log(R))
+ # 1a2) B*(b*log(B) + c)**a = R will arrive unchanged so
+ # lhs is Mul, so take log of both sides:
+ # log(B) + a*log(b*log(B) + c) = log(R)
+ # 1b) d*log(a*B + b) + c*B = R will arrive unchanged so
+ # lhs is Add, so isolate c*B and expand log of both sides:
+ # log(c) + log(B) = log(R - d*log(a*B + b))
+
+ soln = []
+ if not soln:
+ mainlog = _mostfunc(lhs, log, symbol)
+ if mainlog:
+ if lhs.is_Mul and rhs != 0:
+ soln = _lambert(log(lhs) - log(rhs), symbol)
+ elif lhs.is_Add:
+ other = lhs.subs(mainlog, 0)
+ if other and not other.is_Add and [
+ tmp for tmp in other.atoms(Pow)
+ if symbol in tmp.free_symbols]:
+ if not rhs:
+ diff = log(other) - log(other - lhs)
+ else:
+ diff = log(lhs - other) - log(rhs - other)
+ soln = _lambert(expand_log(diff), symbol)
+ else:
+ #it's ready to go
+ soln = _lambert(lhs - rhs, symbol)
+
+ # For the next forms,
+ #
+ # collect on main exp
+ # 2a) (b*B + c)*exp(d*B + g) = R
+ # lhs is mul, so take log of both sides:
+ # log(b*B + c) + d*B = log(R) - g
+ # 2b) g*exp(d*B + h) - b*B = R
+ # lhs is add, so add b*B to both sides,
+ # take the log of both sides and rearrange to give
+ # log(R + b*B) - d*B = log(g) + h
+
+ if not soln:
+ mainexp = _mostfunc(lhs, exp, symbol)
+ if mainexp:
+ lhs = collect(lhs, mainexp)
+ if lhs.is_Mul and rhs != 0:
+ soln = _lambert(expand_log(log(lhs) - log(rhs)), symbol)
+ elif lhs.is_Add:
+ # move all but mainexp-containing term to rhs
+ other = lhs.subs(mainexp, 0)
+ mainterm = lhs - other
+ rhs = rhs - other
+ if (mainterm.could_extract_minus_sign() and
+ rhs.could_extract_minus_sign()):
+ mainterm *= -1
+ rhs *= -1
+ diff = log(mainterm) - log(rhs)
+ soln = _lambert(expand_log(diff), symbol)
+
+ # For the last form:
+ #
+ # 3) d*p**(a*B + g) - b*B = c
+ # collect on main pow, add b*B to both sides,
+ # take log of both sides and rearrange to give
+ # a*B*log(p) - log(b*B + c) = -log(d) - g*log(p)
+ if not soln:
+ mainpow = _mostfunc(lhs, Pow, symbol)
+ if mainpow and symbol in mainpow.exp.free_symbols:
+ lhs = collect(lhs, mainpow)
+ if lhs.is_Mul and rhs != 0:
+ # b*B = 0
+ soln = _lambert(expand_log(log(lhs) - log(rhs)), symbol)
+ elif lhs.is_Add:
+ # move all but mainpow-containing term to rhs
+ other = lhs.subs(mainpow, 0)
+ mainterm = lhs - other
+ rhs = rhs - other
+ diff = log(mainterm) - log(rhs)
+ soln = _lambert(expand_log(diff), symbol)
+
+ if not soln:
+ raise NotImplementedError('%s does not appear to have a solution in '
+ 'terms of LambertW' % f)
+
+ return list(ordered(soln))
+
+
+def bivariate_type(f, x, y, *, first=True):
+ """Given an expression, f, 3 tests will be done to see what type
+ of composite bivariate it might be, options for u(x, y) are::
+
+ x*y
+ x+y
+ x*y+x
+ x*y+y
+
+ If it matches one of these types, ``u(x, y)``, ``P(u)`` and dummy
+ variable ``u`` will be returned. Solving ``P(u)`` for ``u`` and
+ equating the solutions to ``u(x, y)`` and then solving for ``x`` or
+ ``y`` is equivalent to solving the original expression for ``x`` or
+ ``y``. If ``x`` and ``y`` represent two functions in the same
+ variable, e.g. ``x = g(t)`` and ``y = h(t)``, then if ``u(x, y) - p``
+ can be solved for ``t`` then these represent the solutions to
+ ``P(u) = 0`` when ``p`` are the solutions of ``P(u) = 0``.
+
+ Only positive values of ``u`` are considered.
+
+ Examples
+ ========
+
+ >>> from sympy import solve
+ >>> from sympy.solvers.bivariate import bivariate_type
+ >>> from sympy.abc import x, y
+ >>> eq = (x**2 - 3).subs(x, x + y)
+ >>> bivariate_type(eq, x, y)
+ (x + y, _u**2 - 3, _u)
+ >>> uxy, pu, u = _
+ >>> usol = solve(pu, u); usol
+ [sqrt(3)]
+ >>> [solve(uxy - s) for s in solve(pu, u)]
+ [[{x: -y + sqrt(3)}]]
+ >>> all(eq.subs(s).equals(0) for sol in _ for s in sol)
+ True
+
+ """
+
+ u = Dummy('u', positive=True)
+
+ if first:
+ p = Poly(f, x, y)
+ f = p.as_expr()
+ _x = Dummy()
+ _y = Dummy()
+ rv = bivariate_type(Poly(f.subs({x: _x, y: _y}), _x, _y), _x, _y, first=False)
+ if rv:
+ reps = {_x: x, _y: y}
+ return rv[0].xreplace(reps), rv[1].xreplace(reps), rv[2]
+ return
+
+ p = f
+ f = p.as_expr()
+
+ # f(x*y)
+ args = Add.make_args(p.as_expr())
+ new = []
+ for a in args:
+ a = _mexpand(a.subs(x, u/y))
+ free = a.free_symbols
+ if x in free or y in free:
+ break
+ new.append(a)
+ else:
+ return x*y, Add(*new), u
+
+ def ok(f, v, c):
+ new = _mexpand(f.subs(v, c))
+ free = new.free_symbols
+ return None if (x in free or y in free) else new
+
+ # f(a*x + b*y)
+ new = []
+ d = p.degree(x)
+ if p.degree(y) == d:
+ a = root(p.coeff_monomial(x**d), d)
+ b = root(p.coeff_monomial(y**d), d)
+ new = ok(f, x, (u - b*y)/a)
+ if new is not None:
+ return a*x + b*y, new, u
+
+ # f(a*x*y + b*y)
+ new = []
+ d = p.degree(x)
+ if p.degree(y) == d:
+ for itry in range(2):
+ a = root(p.coeff_monomial(x**d*y**d), d)
+ b = root(p.coeff_monomial(y**d), d)
+ new = ok(f, x, (u - b*y)/a/y)
+ if new is not None:
+ return a*x*y + b*y, new, u
+ x, y = y, x
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/decompogen.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/decompogen.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec1b3b683511a34e6f98b9839d112b87517390d8
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/decompogen.py
@@ -0,0 +1,126 @@
+from sympy.core import (Function, Pow, sympify, Expr)
+from sympy.core.relational import Relational
+from sympy.core.singleton import S
+from sympy.polys import Poly, decompose
+from sympy.utilities.misc import func_name
+from sympy.functions.elementary.miscellaneous import Min, Max
+
+
+def decompogen(f, symbol):
+ """
+ Computes General functional decomposition of ``f``.
+ Given an expression ``f``, returns a list ``[f_1, f_2, ..., f_n]``,
+ where::
+ f = f_1 o f_2 o ... f_n = f_1(f_2(... f_n))
+
+ Note: This is a General decomposition function. It also decomposes
+ Polynomials. For only Polynomial decomposition see ``decompose`` in polys.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import x
+ >>> from sympy import decompogen, sqrt, sin, cos
+ >>> decompogen(sin(cos(x)), x)
+ [sin(x), cos(x)]
+ >>> decompogen(sin(x)**2 + sin(x) + 1, x)
+ [x**2 + x + 1, sin(x)]
+ >>> decompogen(sqrt(6*x**2 - 5), x)
+ [sqrt(x), 6*x**2 - 5]
+ >>> decompogen(sin(sqrt(cos(x**2 + 1))), x)
+ [sin(x), sqrt(x), cos(x), x**2 + 1]
+ >>> decompogen(x**4 + 2*x**3 - x - 1, x)
+ [x**2 - x - 1, x**2 + x]
+
+ """
+ f = sympify(f)
+ if not isinstance(f, Expr) or isinstance(f, Relational):
+ raise TypeError('expecting Expr but got: `%s`' % func_name(f))
+ if symbol not in f.free_symbols:
+ return [f]
+
+
+ # ===== Simple Functions ===== #
+ if isinstance(f, (Function, Pow)):
+ if f.is_Pow and f.base == S.Exp1:
+ arg = f.exp
+ else:
+ arg = f.args[0]
+ if arg == symbol:
+ return [f]
+ return [f.subs(arg, symbol)] + decompogen(arg, symbol)
+
+ # ===== Min/Max Functions ===== #
+ if isinstance(f, (Min, Max)):
+ args = list(f.args)
+ d0 = None
+ for i, a in enumerate(args):
+ if not a.has_free(symbol):
+ continue
+ d = decompogen(a, symbol)
+ if len(d) == 1:
+ d = [symbol] + d
+ if d0 is None:
+ d0 = d[1:]
+ elif d[1:] != d0:
+ # decomposition is not the same for each arg:
+ # mark as having no decomposition
+ d = [symbol]
+ break
+ args[i] = d[0]
+ if d[0] == symbol:
+ return [f]
+ return [f.func(*args)] + d0
+
+ # ===== Convert to Polynomial ===== #
+ fp = Poly(f)
+ gens = list(filter(lambda x: symbol in x.free_symbols, fp.gens))
+
+ if len(gens) == 1 and gens[0] != symbol:
+ f1 = f.subs(gens[0], symbol)
+ f2 = gens[0]
+ return [f1] + decompogen(f2, symbol)
+
+ # ===== Polynomial decompose() ====== #
+ try:
+ return decompose(f)
+ except ValueError:
+ return [f]
+
+
+def compogen(g_s, symbol):
+ """
+ Returns the composition of functions.
+ Given a list of functions ``g_s``, returns their composition ``f``,
+ where:
+ f = g_1 o g_2 o .. o g_n
+
+ Note: This is a General composition function. It also composes Polynomials.
+ For only Polynomial composition see ``compose`` in polys.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.decompogen import compogen
+ >>> from sympy.abc import x
+ >>> from sympy import sqrt, sin, cos
+ >>> compogen([sin(x), cos(x)], x)
+ sin(cos(x))
+ >>> compogen([x**2 + x + 1, sin(x)], x)
+ sin(x)**2 + sin(x) + 1
+ >>> compogen([sqrt(x), 6*x**2 - 5], x)
+ sqrt(6*x**2 - 5)
+ >>> compogen([sin(x), sqrt(x), cos(x), x**2 + 1], x)
+ sin(sqrt(cos(x**2 + 1)))
+ >>> compogen([x**2 - x - 1, x**2 + x], x)
+ -x**2 - x + (x**2 + x)**2 - 1
+ """
+ if len(g_s) == 1:
+ return g_s[0]
+
+ foo = g_s[0].subs(symbol, g_s[1])
+
+ if len(g_s) == 2:
+ return foo
+
+ return compogen([foo] + g_s[2:], symbol)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/deutils.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/deutils.py
new file mode 100644
index 0000000000000000000000000000000000000000..c968b65c8d518b82ed308ba932ea9297a3fe3808
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/deutils.py
@@ -0,0 +1,273 @@
+"""Utility functions for classifying and solving
+ordinary and partial differential equations.
+
+Contains
+========
+_preprocess
+ode_order
+_desolve
+
+"""
+from sympy.core import Pow
+from sympy.core.function import Derivative, AppliedUndef
+from sympy.core.relational import Equality
+from sympy.core.symbol import Wild
+
+def _preprocess(expr, func=None, hint='_Integral'):
+ """Prepare expr for solving by making sure that differentiation
+ is done so that only func remains in unevaluated derivatives and
+ (if hint does not end with _Integral) that doit is applied to all
+ other derivatives. If hint is None, do not do any differentiation.
+ (Currently this may cause some simple differential equations to
+ fail.)
+
+ In case func is None, an attempt will be made to autodetect the
+ function to be solved for.
+
+ >>> from sympy.solvers.deutils import _preprocess
+ >>> from sympy import Derivative, Function
+ >>> from sympy.abc import x, y, z
+ >>> f, g = map(Function, 'fg')
+
+ If f(x)**p == 0 and p>0 then we can solve for f(x)=0
+ >>> _preprocess((f(x).diff(x)-4)**5, f(x))
+ (Derivative(f(x), x) - 4, f(x))
+
+ Apply doit to derivatives that contain more than the function
+ of interest:
+
+ >>> _preprocess(Derivative(f(x) + x, x))
+ (Derivative(f(x), x) + 1, f(x))
+
+ Do others if the differentiation variable(s) intersect with those
+ of the function of interest or contain the function of interest:
+
+ >>> _preprocess(Derivative(g(x), y, z), f(y))
+ (0, f(y))
+ >>> _preprocess(Derivative(f(y), z), f(y))
+ (0, f(y))
+
+ Do others if the hint does not end in '_Integral' (the default
+ assumes that it does):
+
+ >>> _preprocess(Derivative(g(x), y), f(x))
+ (Derivative(g(x), y), f(x))
+ >>> _preprocess(Derivative(f(x), y), f(x), hint='')
+ (0, f(x))
+
+ Do not do any derivatives if hint is None:
+
+ >>> eq = Derivative(f(x) + 1, x) + Derivative(f(x), y)
+ >>> _preprocess(eq, f(x), hint=None)
+ (Derivative(f(x) + 1, x) + Derivative(f(x), y), f(x))
+
+ If it's not clear what the function of interest is, it must be given:
+
+ >>> eq = Derivative(f(x) + g(x), x)
+ >>> _preprocess(eq, g(x))
+ (Derivative(f(x), x) + Derivative(g(x), x), g(x))
+ >>> try: _preprocess(eq)
+ ... except ValueError: print("A ValueError was raised.")
+ A ValueError was raised.
+
+ """
+ if isinstance(expr, Pow):
+ # if f(x)**p=0 then f(x)=0 (p>0)
+ if (expr.exp).is_positive:
+ expr = expr.base
+ derivs = expr.atoms(Derivative)
+ if not func:
+ funcs = set().union(*[d.atoms(AppliedUndef) for d in derivs])
+ if len(funcs) != 1:
+ raise ValueError('The function cannot be '
+ 'automatically detected for %s.' % expr)
+ func = funcs.pop()
+ fvars = set(func.args)
+ if hint is None:
+ return expr, func
+ reps = [(d, d.doit()) for d in derivs if not hint.endswith('_Integral') or
+ d.has(func) or set(d.variables) & fvars]
+ eq = expr.subs(reps)
+ return eq, func
+
+
+def ode_order(expr, func):
+ """
+ Returns the order of a given differential
+ equation with respect to func.
+
+ This function is implemented recursively.
+
+ Examples
+ ========
+
+ >>> from sympy import Function
+ >>> from sympy.solvers.deutils import ode_order
+ >>> from sympy.abc import x
+ >>> f, g = map(Function, ['f', 'g'])
+ >>> ode_order(f(x).diff(x, 2) + f(x).diff(x)**2 +
+ ... f(x).diff(x), f(x))
+ 2
+ >>> ode_order(f(x).diff(x, 2) + g(x).diff(x, 3), f(x))
+ 2
+ >>> ode_order(f(x).diff(x, 2) + g(x).diff(x, 3), g(x))
+ 3
+
+ """
+ a = Wild('a', exclude=[func])
+ if expr.match(a):
+ return 0
+
+ if isinstance(expr, Derivative):
+ if expr.args[0] == func:
+ return len(expr.variables)
+ else:
+ args = expr.args[0].args
+ rv = len(expr.variables)
+ if args:
+ rv += max(ode_order(_, func) for _ in args)
+ return rv
+ else:
+ return max(ode_order(_, func) for _ in expr.args) if expr.args else 0
+
+
+def _desolve(eq, func=None, hint="default", ics=None, simplify=True, *, prep=True, **kwargs):
+ """This is a helper function to dsolve and pdsolve in the ode
+ and pde modules.
+
+ If the hint provided to the function is "default", then a dict with
+ the following keys are returned
+
+ 'func' - It provides the function for which the differential equation
+ has to be solved. This is useful when the expression has
+ more than one function in it.
+
+ 'default' - The default key as returned by classifier functions in ode
+ and pde.py
+
+ 'hint' - The hint given by the user for which the differential equation
+ is to be solved. If the hint given by the user is 'default',
+ then the value of 'hint' and 'default' is the same.
+
+ 'order' - The order of the function as returned by ode_order
+
+ 'match' - It returns the match as given by the classifier functions, for
+ the default hint.
+
+ If the hint provided to the function is not "default" and is not in
+ ('all', 'all_Integral', 'best'), then a dict with the above mentioned keys
+ is returned along with the keys which are returned when dict in
+ classify_ode or classify_pde is set True
+
+ If the hint given is in ('all', 'all_Integral', 'best'), then this function
+ returns a nested dict, with the keys, being the set of classified hints
+ returned by classifier functions, and the values being the dict of form
+ as mentioned above.
+
+ Key 'eq' is a common key to all the above mentioned hints which returns an
+ expression if eq given by user is an Equality.
+
+ See Also
+ ========
+ classify_ode(ode.py)
+ classify_pde(pde.py)
+ """
+ if isinstance(eq, Equality):
+ eq = eq.lhs - eq.rhs
+
+ # preprocess the equation and find func if not given
+ if prep or func is None:
+ eq, func = _preprocess(eq, func)
+ prep = False
+
+ # type is an argument passed by the solve functions in ode and pde.py
+ # that identifies whether the function caller is an ordinary
+ # or partial differential equation. Accordingly corresponding
+ # changes are made in the function.
+ type = kwargs.get('type', None)
+ xi = kwargs.get('xi')
+ eta = kwargs.get('eta')
+ x0 = kwargs.get('x0', 0)
+ terms = kwargs.get('n')
+
+ if type == 'ode':
+ from sympy.solvers.ode import classify_ode, allhints
+ classifier = classify_ode
+ string = 'ODE '
+ dummy = ''
+
+ elif type == 'pde':
+ from sympy.solvers.pde import classify_pde, allhints
+ classifier = classify_pde
+ string = 'PDE '
+ dummy = 'p'
+
+ # Magic that should only be used internally. Prevents classify_ode from
+ # being called more than it needs to be by passing its results through
+ # recursive calls.
+ if kwargs.get('classify', True):
+ hints = classifier(eq, func, dict=True, ics=ics, xi=xi, eta=eta,
+ n=terms, x0=x0, hint=hint, prep=prep)
+
+ else:
+ # Here is what all this means:
+ #
+ # hint: The hint method given to _desolve() by the user.
+ # hints: The dictionary of hints that match the DE, along with other
+ # information (including the internal pass-through magic).
+ # default: The default hint to return, the first hint from allhints
+ # that matches the hint; obtained from classify_ode().
+ # match: Dictionary containing the match dictionary for each hint
+ # (the parts of the DE for solving). When going through the
+ # hints in "all", this holds the match string for the current
+ # hint.
+ # order: The order of the DE, as determined by ode_order().
+ hints = kwargs.get('hint',
+ {'default': hint,
+ hint: kwargs['match'],
+ 'order': kwargs['order']})
+ if not hints['default']:
+ # classify_ode will set hints['default'] to None if no hints match.
+ if hint not in allhints and hint != 'default':
+ raise ValueError("Hint not recognized: " + hint)
+ elif hint not in hints['ordered_hints'] and hint != 'default':
+ raise ValueError(string + str(eq) + " does not match hint " + hint)
+ # If dsolve can't solve the purely algebraic equation then dsolve will raise
+ # ValueError
+ elif hints['order'] == 0:
+ raise ValueError(
+ str(eq) + " is not a solvable differential equation in " + str(func))
+ else:
+ raise NotImplementedError(dummy + "solve" + ": Cannot solve " + str(eq))
+ if hint == 'default':
+ return _desolve(eq, func, ics=ics, hint=hints['default'], simplify=simplify,
+ prep=prep, x0=x0, classify=False, order=hints['order'],
+ match=hints[hints['default']], xi=xi, eta=eta, n=terms, type=type)
+ elif hint in ('all', 'all_Integral', 'best'):
+ retdict = {}
+ gethints = set(hints) - {'order', 'default', 'ordered_hints'}
+ if hint == 'all_Integral':
+ for i in hints:
+ if i.endswith('_Integral'):
+ gethints.remove(i[:-len('_Integral')])
+ # special cases
+ for k in ["1st_homogeneous_coeff_best", "1st_power_series",
+ "lie_group", "2nd_power_series_ordinary", "2nd_power_series_regular"]:
+ if k in gethints:
+ gethints.remove(k)
+ for i in gethints:
+ sol = _desolve(eq, func, ics=ics, hint=i, x0=x0, simplify=simplify, prep=prep,
+ classify=False, n=terms, order=hints['order'], match=hints[i], type=type)
+ retdict[i] = sol
+ retdict['all'] = True
+ retdict['eq'] = eq
+ return retdict
+ elif hint not in allhints: # and hint not in ('default', 'ordered_hints'):
+ raise ValueError("Hint not recognized: " + hint)
+ elif hint not in hints:
+ raise ValueError(string + str(eq) + " does not match hint " + hint)
+ else:
+ # Key added to identify the hint needed to solve the equation
+ hints['hint'] = hint
+ hints.update({'func': func, 'eq': eq})
+ return hints
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/inequalities.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/inequalities.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ef1bb984f1c89a39a348553e5bff23af16f32d4
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/inequalities.py
@@ -0,0 +1,984 @@
+"""Tools for solving inequalities and systems of inequalities. """
+import itertools
+
+from sympy.calculus.util import (continuous_domain, periodicity,
+ function_range)
+from sympy.core import Symbol, Dummy, sympify
+from sympy.core.exprtools import factor_terms
+from sympy.core.relational import Relational, Eq, Ge, Lt
+from sympy.sets.sets import Interval, FiniteSet, Union, Intersection
+from sympy.core.singleton import S
+from sympy.core.function import expand_mul
+from sympy.functions.elementary.complexes import im, Abs
+from sympy.logic import And
+from sympy.polys import Poly, PolynomialError, parallel_poly_from_expr
+from sympy.polys.polyutils import _nsort
+from sympy.solvers.solveset import solvify, solveset
+from sympy.utilities.iterables import sift, iterable
+from sympy.utilities.misc import filldedent
+
+
+def solve_poly_inequality(poly, rel):
+ """Solve a polynomial inequality with rational coefficients.
+
+ Examples
+ ========
+
+ >>> from sympy import solve_poly_inequality, Poly
+ >>> from sympy.abc import x
+
+ >>> solve_poly_inequality(Poly(x, x, domain='ZZ'), '==')
+ [{0}]
+
+ >>> solve_poly_inequality(Poly(x**2 - 1, x, domain='ZZ'), '!=')
+ [Interval.open(-oo, -1), Interval.open(-1, 1), Interval.open(1, oo)]
+
+ >>> solve_poly_inequality(Poly(x**2 - 1, x, domain='ZZ'), '==')
+ [{-1}, {1}]
+
+ See Also
+ ========
+ solve_poly_inequalities
+ """
+ if not isinstance(poly, Poly):
+ raise ValueError(
+ 'For efficiency reasons, `poly` should be a Poly instance')
+ if poly.as_expr().is_number:
+ t = Relational(poly.as_expr(), 0, rel)
+ if t is S.true:
+ return [S.Reals]
+ elif t is S.false:
+ return [S.EmptySet]
+ else:
+ raise NotImplementedError(
+ "could not determine truth value of %s" % t)
+
+ reals, intervals = poly.real_roots(multiple=False), []
+
+ if rel == '==':
+ for root, _ in reals:
+ interval = Interval(root, root)
+ intervals.append(interval)
+ elif rel == '!=':
+ left = S.NegativeInfinity
+
+ for right, _ in reals + [(S.Infinity, 1)]:
+ interval = Interval(left, right, True, True)
+ intervals.append(interval)
+ left = right
+ else:
+ if poly.LC() > 0:
+ sign = +1
+ else:
+ sign = -1
+
+ eq_sign, equal = None, False
+
+ if rel == '>':
+ eq_sign = +1
+ elif rel == '<':
+ eq_sign = -1
+ elif rel == '>=':
+ eq_sign, equal = +1, True
+ elif rel == '<=':
+ eq_sign, equal = -1, True
+ else:
+ raise ValueError("'%s' is not a valid relation" % rel)
+
+ right, right_open = S.Infinity, True
+
+ for left, multiplicity in reversed(reals):
+ if multiplicity % 2:
+ if sign == eq_sign:
+ intervals.insert(
+ 0, Interval(left, right, not equal, right_open))
+
+ sign, right, right_open = -sign, left, not equal
+ else:
+ if sign == eq_sign and not equal:
+ intervals.insert(
+ 0, Interval(left, right, True, right_open))
+ right, right_open = left, True
+ elif sign != eq_sign and equal:
+ intervals.insert(0, Interval(left, left))
+
+ if sign == eq_sign:
+ intervals.insert(
+ 0, Interval(S.NegativeInfinity, right, True, right_open))
+
+ return intervals
+
+
+def solve_poly_inequalities(polys):
+ """Solve polynomial inequalities with rational coefficients.
+
+ Examples
+ ========
+
+ >>> from sympy import Poly
+ >>> from sympy.solvers.inequalities import solve_poly_inequalities
+ >>> from sympy.abc import x
+ >>> solve_poly_inequalities(((
+ ... Poly(x**2 - 3), ">"), (
+ ... Poly(-x**2 + 1), ">")))
+ Union(Interval.open(-oo, -sqrt(3)), Interval.open(-1, 1), Interval.open(sqrt(3), oo))
+ """
+ return Union(*[s for p in polys for s in solve_poly_inequality(*p)])
+
+
+def solve_rational_inequalities(eqs):
+ """Solve a system of rational inequalities with rational coefficients.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import x
+ >>> from sympy import solve_rational_inequalities, Poly
+
+ >>> solve_rational_inequalities([[
+ ... ((Poly(-x + 1), Poly(1, x)), '>='),
+ ... ((Poly(-x + 1), Poly(1, x)), '<=')]])
+ {1}
+
+ >>> solve_rational_inequalities([[
+ ... ((Poly(x), Poly(1, x)), '!='),
+ ... ((Poly(-x + 1), Poly(1, x)), '>=')]])
+ Union(Interval.open(-oo, 0), Interval.Lopen(0, 1))
+
+ See Also
+ ========
+ solve_poly_inequality
+ """
+ result = S.EmptySet
+
+ for _eqs in eqs:
+ if not _eqs:
+ continue
+
+ global_intervals = [Interval(S.NegativeInfinity, S.Infinity)]
+
+ for (numer, denom), rel in _eqs:
+ numer_intervals = solve_poly_inequality(numer*denom, rel)
+ denom_intervals = solve_poly_inequality(denom, '==')
+
+ intervals = []
+
+ for numer_interval, global_interval in itertools.product(
+ numer_intervals, global_intervals):
+ interval = numer_interval.intersect(global_interval)
+
+ if interval is not S.EmptySet:
+ intervals.append(interval)
+
+ global_intervals = intervals
+
+ intervals = []
+
+ for global_interval in global_intervals:
+ for denom_interval in denom_intervals:
+ global_interval -= denom_interval
+
+ if global_interval is not S.EmptySet:
+ intervals.append(global_interval)
+
+ global_intervals = intervals
+
+ if not global_intervals:
+ break
+
+ for interval in global_intervals:
+ result = result.union(interval)
+
+ return result
+
+
+def reduce_rational_inequalities(exprs, gen, relational=True):
+ """Reduce a system of rational inequalities with rational coefficients.
+
+ Examples
+ ========
+
+ >>> from sympy import Symbol
+ >>> from sympy.solvers.inequalities import reduce_rational_inequalities
+
+ >>> x = Symbol('x', real=True)
+
+ >>> reduce_rational_inequalities([[x**2 <= 0]], x)
+ Eq(x, 0)
+
+ >>> reduce_rational_inequalities([[x + 2 > 0]], x)
+ -2 < x
+ >>> reduce_rational_inequalities([[(x + 2, ">")]], x)
+ -2 < x
+ >>> reduce_rational_inequalities([[x + 2]], x)
+ Eq(x, -2)
+
+ This function find the non-infinite solution set so if the unknown symbol
+ is declared as extended real rather than real then the result may include
+ finiteness conditions:
+
+ >>> y = Symbol('y', extended_real=True)
+ >>> reduce_rational_inequalities([[y + 2 > 0]], y)
+ (-2 < y) & (y < oo)
+ """
+ exact = True
+ eqs = []
+ solution = S.Reals if exprs else S.EmptySet
+ for _exprs in exprs:
+ _eqs = []
+
+ for expr in _exprs:
+ if isinstance(expr, tuple):
+ expr, rel = expr
+ else:
+ if expr.is_Relational:
+ expr, rel = expr.lhs - expr.rhs, expr.rel_op
+ else:
+ expr, rel = expr, '=='
+
+ if expr is S.true:
+ numer, denom, rel = S.Zero, S.One, '=='
+ elif expr is S.false:
+ numer, denom, rel = S.One, S.One, '=='
+ else:
+ numer, denom = expr.together().as_numer_denom()
+
+ try:
+ (numer, denom), opt = parallel_poly_from_expr(
+ (numer, denom), gen)
+ except PolynomialError:
+ raise PolynomialError(filldedent('''
+ only polynomials and rational functions are
+ supported in this context.
+ '''))
+
+ if not opt.domain.is_Exact:
+ numer, denom, exact = numer.to_exact(), denom.to_exact(), False
+
+ domain = opt.domain.get_exact()
+
+ if not (domain.is_ZZ or domain.is_QQ):
+ expr = numer/denom
+ expr = Relational(expr, 0, rel)
+ solution &= solve_univariate_inequality(expr, gen, relational=False)
+ else:
+ _eqs.append(((numer, denom), rel))
+
+ if _eqs:
+ eqs.append(_eqs)
+
+ if eqs:
+ solution &= solve_rational_inequalities(eqs)
+ exclude = solve_rational_inequalities([[((d, d.one), '==')
+ for i in eqs for ((n, d), _) in i if d.has(gen)]])
+ solution -= exclude
+
+ if not exact and solution:
+ solution = solution.evalf()
+
+ if relational:
+ solution = solution.as_relational(gen)
+
+ return solution
+
+
+def reduce_abs_inequality(expr, rel, gen):
+ """Reduce an inequality with nested absolute values.
+
+ Examples
+ ========
+
+ >>> from sympy import reduce_abs_inequality, Abs, Symbol
+ >>> x = Symbol('x', real=True)
+
+ >>> reduce_abs_inequality(Abs(x - 5) - 3, '<', x)
+ (2 < x) & (x < 8)
+
+ >>> reduce_abs_inequality(Abs(x + 2)*3 - 13, '<', x)
+ (-19/3 < x) & (x < 7/3)
+
+ See Also
+ ========
+
+ reduce_abs_inequalities
+ """
+ if gen.is_extended_real is False:
+ raise TypeError(filldedent('''
+ Cannot solve inequalities with absolute values containing
+ non-real variables.
+ '''))
+
+ def _bottom_up_scan(expr):
+ exprs = []
+
+ if expr.is_Add or expr.is_Mul:
+ op = expr.func
+
+ for arg in expr.args:
+ _exprs = _bottom_up_scan(arg)
+
+ if not exprs:
+ exprs = _exprs
+ else:
+ exprs = [(op(expr, _expr), conds + _conds) for (expr, conds), (_expr, _conds) in
+ itertools.product(exprs, _exprs)]
+ elif expr.is_Pow:
+ n = expr.exp
+ if not n.is_Integer:
+ raise ValueError("Only Integer Powers are allowed on Abs.")
+
+ exprs.extend((expr**n, conds) for expr, conds in _bottom_up_scan(expr.base))
+ elif isinstance(expr, Abs):
+ _exprs = _bottom_up_scan(expr.args[0])
+
+ for expr, conds in _exprs:
+ exprs.append(( expr, conds + [Ge(expr, 0)]))
+ exprs.append((-expr, conds + [Lt(expr, 0)]))
+ else:
+ exprs = [(expr, [])]
+
+ return exprs
+
+ mapping = {'<': '>', '<=': '>='}
+ inequalities = []
+
+ for expr, conds in _bottom_up_scan(expr):
+ if rel not in mapping.keys():
+ expr = Relational( expr, 0, rel)
+ else:
+ expr = Relational(-expr, 0, mapping[rel])
+
+ inequalities.append([expr] + conds)
+
+ return reduce_rational_inequalities(inequalities, gen)
+
+
+def reduce_abs_inequalities(exprs, gen):
+ """Reduce a system of inequalities with nested absolute values.
+
+ Examples
+ ========
+
+ >>> from sympy import reduce_abs_inequalities, Abs, Symbol
+ >>> x = Symbol('x', extended_real=True)
+
+ >>> reduce_abs_inequalities([(Abs(3*x - 5) - 7, '<'),
+ ... (Abs(x + 25) - 13, '>')], x)
+ (-2/3 < x) & (x < 4) & (((-oo < x) & (x < -38)) | ((-12 < x) & (x < oo)))
+
+ >>> reduce_abs_inequalities([(Abs(x - 4) + Abs(3*x - 5) - 7, '<')], x)
+ (1/2 < x) & (x < 4)
+
+ See Also
+ ========
+
+ reduce_abs_inequality
+ """
+ return And(*[ reduce_abs_inequality(expr, rel, gen)
+ for expr, rel in exprs ])
+
+
+def solve_univariate_inequality(expr, gen, relational=True, domain=S.Reals, continuous=False):
+ """Solves a real univariate inequality.
+
+ Parameters
+ ==========
+
+ expr : Relational
+ The target inequality
+ gen : Symbol
+ The variable for which the inequality is solved
+ relational : bool
+ A Relational type output is expected or not
+ domain : Set
+ The domain over which the equation is solved
+ continuous: bool
+ True if expr is known to be continuous over the given domain
+ (and so continuous_domain() does not need to be called on it)
+
+ Raises
+ ======
+
+ NotImplementedError
+ The solution of the inequality cannot be determined due to limitation
+ in :func:`sympy.solvers.solveset.solvify`.
+
+ Notes
+ =====
+
+ Currently, we cannot solve all the inequalities due to limitations in
+ :func:`sympy.solvers.solveset.solvify`. Also, the solution returned for trigonometric inequalities
+ are restricted in its periodic interval.
+
+ See Also
+ ========
+
+ sympy.solvers.solveset.solvify: solver returning solveset solutions with solve's output API
+
+ Examples
+ ========
+
+ >>> from sympy import solve_univariate_inequality, Symbol, sin, Interval, S
+ >>> x = Symbol('x')
+
+ >>> solve_univariate_inequality(x**2 >= 4, x)
+ ((2 <= x) & (x < oo)) | ((-oo < x) & (x <= -2))
+
+ >>> solve_univariate_inequality(x**2 >= 4, x, relational=False)
+ Union(Interval(-oo, -2), Interval(2, oo))
+
+ >>> domain = Interval(0, S.Infinity)
+ >>> solve_univariate_inequality(x**2 >= 4, x, False, domain)
+ Interval(2, oo)
+
+ >>> solve_univariate_inequality(sin(x) > 0, x, relational=False)
+ Interval.open(0, pi)
+
+ """
+ from sympy.solvers.solvers import denoms
+
+ if domain.is_subset(S.Reals) is False:
+ raise NotImplementedError(filldedent('''
+ Inequalities in the complex domain are
+ not supported. Try the real domain by
+ setting domain=S.Reals'''))
+ elif domain is not S.Reals:
+ rv = solve_univariate_inequality(
+ expr, gen, relational=False, continuous=continuous).intersection(domain)
+ if relational:
+ rv = rv.as_relational(gen)
+ return rv
+ else:
+ pass # continue with attempt to solve in Real domain
+
+ # This keeps the function independent of the assumptions about `gen`.
+ # `solveset` makes sure this function is called only when the domain is
+ # real.
+ _gen = gen
+ _domain = domain
+ if gen.is_extended_real is False:
+ rv = S.EmptySet
+ return rv if not relational else rv.as_relational(_gen)
+ elif gen.is_extended_real is None:
+ gen = Dummy('gen', extended_real=True)
+ try:
+ expr = expr.xreplace({_gen: gen})
+ except TypeError:
+ raise TypeError(filldedent('''
+ When gen is real, the relational has a complex part
+ which leads to an invalid comparison like I < 0.
+ '''))
+
+ rv = None
+
+ if expr is S.true:
+ rv = domain
+
+ elif expr is S.false:
+ rv = S.EmptySet
+
+ else:
+ e = expr.lhs - expr.rhs
+ period = periodicity(e, gen)
+ if period == S.Zero:
+ e = expand_mul(e)
+ const = expr.func(e, 0)
+ if const is S.true:
+ rv = domain
+ elif const is S.false:
+ rv = S.EmptySet
+ elif period is not None:
+ frange = function_range(e, gen, domain)
+
+ rel = expr.rel_op
+ if rel in ('<', '<='):
+ if expr.func(frange.sup, 0):
+ rv = domain
+ elif not expr.func(frange.inf, 0):
+ rv = S.EmptySet
+
+ elif rel in ('>', '>='):
+ if expr.func(frange.inf, 0):
+ rv = domain
+ elif not expr.func(frange.sup, 0):
+ rv = S.EmptySet
+
+ inf, sup = domain.inf, domain.sup
+ if sup - inf is S.Infinity:
+ domain = Interval(0, period, False, True).intersect(_domain)
+ _domain = domain
+
+ if rv is None:
+ n, d = e.as_numer_denom()
+ try:
+ if gen not in n.free_symbols and len(e.free_symbols) > 1:
+ raise ValueError
+ # this might raise ValueError on its own
+ # or it might give None...
+ solns = solvify(e, gen, domain)
+ if solns is None:
+ # in which case we raise ValueError
+ raise ValueError
+ except (ValueError, NotImplementedError):
+ # replace gen with generic x since it's
+ # univariate anyway
+ raise NotImplementedError(filldedent('''
+ The inequality, %s, cannot be solved using
+ solve_univariate_inequality.
+ ''' % expr.subs(gen, Symbol('x'))))
+
+ expanded_e = expand_mul(e)
+ def valid(x):
+ # this is used to see if gen=x satisfies the
+ # relational by substituting it into the
+ # expanded form and testing against 0, e.g.
+ # if expr = x*(x + 1) < 2 then e = x*(x + 1) - 2
+ # and expanded_e = x**2 + x - 2; the test is
+ # whether a given value of x satisfies
+ # x**2 + x - 2 < 0
+ #
+ # expanded_e, expr and gen used from enclosing scope
+ v = expanded_e.subs(gen, expand_mul(x))
+ try:
+ r = expr.func(v, 0)
+ except TypeError:
+ r = S.false
+ if r in (S.true, S.false):
+ return r
+ if v.is_extended_real is False:
+ return S.false
+ else:
+ v = v.n(2)
+ if v.is_comparable:
+ return expr.func(v, 0)
+ # not comparable or couldn't be evaluated
+ raise NotImplementedError(
+ 'relationship did not evaluate: %s' % r)
+
+ singularities = []
+ for d in denoms(expr, gen):
+ singularities.extend(solvify(d, gen, domain))
+ if not continuous:
+ domain = continuous_domain(expanded_e, gen, domain)
+
+ include_x = '=' in expr.rel_op and expr.rel_op != '!='
+
+ try:
+ discontinuities = set(domain.boundary -
+ FiniteSet(domain.inf, domain.sup))
+ # remove points that are not between inf and sup of domain
+ critical_points = FiniteSet(*(solns + singularities + list(
+ discontinuities))).intersection(
+ Interval(domain.inf, domain.sup,
+ domain.inf not in domain, domain.sup not in domain))
+ if all(r.is_number for r in critical_points):
+ reals = _nsort(critical_points, separated=True)[0]
+ else:
+ sifted = sift(critical_points, lambda x: x.is_extended_real)
+ if sifted[None]:
+ # there were some roots that weren't known
+ # to be real
+ raise NotImplementedError
+ try:
+ reals = sifted[True]
+ if len(reals) > 1:
+ reals = sorted(reals)
+ except TypeError:
+ raise NotImplementedError
+ except NotImplementedError:
+ raise NotImplementedError('sorting of these roots is not supported')
+
+ # If expr contains imaginary coefficients, only take real
+ # values of x for which the imaginary part is 0
+ make_real = S.Reals
+ if im(expanded_e) != S.Zero:
+ check = True
+ im_sol = FiniteSet()
+ try:
+ a = solveset(im(expanded_e), gen, domain)
+ if not isinstance(a, Interval):
+ for z in a:
+ if z not in singularities and valid(z) and z.is_extended_real:
+ im_sol += FiniteSet(z)
+ else:
+ start, end = a.inf, a.sup
+ for z in _nsort(critical_points + FiniteSet(end)):
+ valid_start = valid(start)
+ if start != end:
+ valid_z = valid(z)
+ pt = _pt(start, z)
+ if pt not in singularities and pt.is_extended_real and valid(pt):
+ if valid_start and valid_z:
+ im_sol += Interval(start, z)
+ elif valid_start:
+ im_sol += Interval.Ropen(start, z)
+ elif valid_z:
+ im_sol += Interval.Lopen(start, z)
+ else:
+ im_sol += Interval.open(start, z)
+ start = z
+ for s in singularities:
+ im_sol -= FiniteSet(s)
+ except (TypeError):
+ im_sol = S.Reals
+ check = False
+
+ if im_sol is S.EmptySet:
+ raise ValueError(filldedent('''
+ %s contains imaginary parts which cannot be
+ made 0 for any value of %s satisfying the
+ inequality, leading to relations like I < 0.
+ ''' % (expr.subs(gen, _gen), _gen)))
+
+ make_real = make_real.intersect(im_sol)
+
+ sol_sets = [S.EmptySet]
+
+ start = domain.inf
+ if start in domain and valid(start) and start.is_finite:
+ sol_sets.append(FiniteSet(start))
+
+ for x in reals:
+ end = x
+
+ if valid(_pt(start, end)):
+ sol_sets.append(Interval(start, end, True, True))
+
+ if x in singularities:
+ singularities.remove(x)
+ else:
+ if x in discontinuities:
+ discontinuities.remove(x)
+ _valid = valid(x)
+ else: # it's a solution
+ _valid = include_x
+ if _valid:
+ sol_sets.append(FiniteSet(x))
+
+ start = end
+
+ end = domain.sup
+ if end in domain and valid(end) and end.is_finite:
+ sol_sets.append(FiniteSet(end))
+
+ if valid(_pt(start, end)):
+ sol_sets.append(Interval.open(start, end))
+
+ if im(expanded_e) != S.Zero and check:
+ rv = (make_real).intersect(_domain)
+ else:
+ rv = Intersection(
+ (Union(*sol_sets)), make_real, _domain).subs(gen, _gen)
+
+ return rv if not relational else rv.as_relational(_gen)
+
+
+def _pt(start, end):
+ """Return a point between start and end"""
+ if not start.is_infinite and not end.is_infinite:
+ pt = (start + end)/2
+ elif start.is_infinite and end.is_infinite:
+ pt = S.Zero
+ else:
+ if (start.is_infinite and start.is_extended_positive is None or
+ end.is_infinite and end.is_extended_positive is None):
+ raise ValueError('cannot proceed with unsigned infinite values')
+ if (end.is_infinite and end.is_extended_negative or
+ start.is_infinite and start.is_extended_positive):
+ start, end = end, start
+ # if possible, use a multiple of self which has
+ # better behavior when checking assumptions than
+ # an expression obtained by adding or subtracting 1
+ if end.is_infinite:
+ if start.is_extended_positive:
+ pt = start*2
+ elif start.is_extended_negative:
+ pt = start*S.Half
+ else:
+ pt = start + 1
+ elif start.is_infinite:
+ if end.is_extended_positive:
+ pt = end*S.Half
+ elif end.is_extended_negative:
+ pt = end*2
+ else:
+ pt = end - 1
+ return pt
+
+
+def _solve_inequality(ie, s, linear=False):
+ """Return the inequality with s isolated on the left, if possible.
+ If the relationship is non-linear, a solution involving And or Or
+ may be returned. False or True are returned if the relationship
+ is never True or always True, respectively.
+
+ If `linear` is True (default is False) an `s`-dependent expression
+ will be isolated on the left, if possible
+ but it will not be solved for `s` unless the expression is linear
+ in `s`. Furthermore, only "safe" operations which do not change the
+ sense of the relationship are applied: no division by an unsigned
+ value is attempted unless the relationship involves Eq or Ne and
+ no division by a value not known to be nonzero is ever attempted.
+
+ Examples
+ ========
+
+ >>> from sympy import Eq, Symbol
+ >>> from sympy.solvers.inequalities import _solve_inequality as f
+ >>> from sympy.abc import x, y
+
+ For linear expressions, the symbol can be isolated:
+
+ >>> f(x - 2 < 0, x)
+ x < 2
+ >>> f(-x - 6 < x, x)
+ x > -3
+
+ Sometimes nonlinear relationships will be False
+
+ >>> f(x**2 + 4 < 0, x)
+ False
+
+ Or they may involve more than one region of values:
+
+ >>> f(x**2 - 4 < 0, x)
+ (-2 < x) & (x < 2)
+
+ To restrict the solution to a relational, set linear=True
+ and only the x-dependent portion will be isolated on the left:
+
+ >>> f(x**2 - 4 < 0, x, linear=True)
+ x**2 < 4
+
+ Division of only nonzero quantities is allowed, so x cannot
+ be isolated by dividing by y:
+
+ >>> y.is_nonzero is None # it is unknown whether it is 0 or not
+ True
+ >>> f(x*y < 1, x)
+ x*y < 1
+
+ And while an equality (or inequality) still holds after dividing by a
+ non-zero quantity
+
+ >>> nz = Symbol('nz', nonzero=True)
+ >>> f(Eq(x*nz, 1), x)
+ Eq(x, 1/nz)
+
+ the sign must be known for other inequalities involving > or <:
+
+ >>> f(x*nz <= 1, x)
+ nz*x <= 1
+ >>> p = Symbol('p', positive=True)
+ >>> f(x*p <= 1, x)
+ x <= 1/p
+
+ When there are denominators in the original expression that
+ are removed by expansion, conditions for them will be returned
+ as part of the result:
+
+ >>> f(x < x*(2/x - 1), x)
+ (x < 1) & Ne(x, 0)
+ """
+ from sympy.solvers.solvers import denoms
+ if s not in ie.free_symbols:
+ return ie
+ if ie.rhs == s:
+ ie = ie.reversed
+ if ie.lhs == s and s not in ie.rhs.free_symbols:
+ return ie
+
+ def classify(ie, s, i):
+ # return True or False if ie evaluates when substituting s with
+ # i else None (if unevaluated) or NaN (when there is an error
+ # in evaluating)
+ try:
+ v = ie.subs(s, i)
+ if v is S.NaN:
+ return v
+ elif v not in (True, False):
+ return
+ return v
+ except TypeError:
+ return S.NaN
+
+ rv = None
+ oo = S.Infinity
+ expr = ie.lhs - ie.rhs
+ try:
+ p = Poly(expr, s)
+ if p.degree() == 0:
+ rv = ie.func(p.as_expr(), 0)
+ elif not linear and p.degree() > 1:
+ # handle in except clause
+ raise NotImplementedError
+ except (PolynomialError, NotImplementedError):
+ if not linear:
+ try:
+ rv = reduce_rational_inequalities([[ie]], s)
+ except PolynomialError:
+ rv = solve_univariate_inequality(ie, s)
+ # remove restrictions wrt +/-oo that may have been
+ # applied when using sets to simplify the relationship
+ okoo = classify(ie, s, oo)
+ if okoo is S.true and classify(rv, s, oo) is S.false:
+ rv = rv.subs(s < oo, True)
+ oknoo = classify(ie, s, -oo)
+ if (oknoo is S.true and
+ classify(rv, s, -oo) is S.false):
+ rv = rv.subs(-oo < s, True)
+ rv = rv.subs(s > -oo, True)
+ if rv is S.true:
+ rv = (s <= oo) if okoo is S.true else (s < oo)
+ if oknoo is not S.true:
+ rv = And(-oo < s, rv)
+ else:
+ p = Poly(expr)
+
+ conds = []
+ if rv is None:
+ e = p.as_expr() # this is in expanded form
+ # Do a safe inversion of e, moving non-s terms
+ # to the rhs and dividing by a nonzero factor if
+ # the relational is Eq/Ne; for other relationals
+ # the sign must also be positive or negative
+ rhs = 0
+ b, ax = e.as_independent(s, as_Add=True)
+ e -= b
+ rhs -= b
+ ef = factor_terms(e)
+ a, e = ef.as_independent(s, as_Add=False)
+ if (a.is_zero != False or # don't divide by potential 0
+ a.is_negative ==
+ a.is_positive is None and # if sign is not known then
+ ie.rel_op not in ('!=', '==')): # reject if not Eq/Ne
+ e = ef
+ a = S.One
+ rhs /= a
+ if a.is_positive:
+ rv = ie.func(e, rhs)
+ else:
+ rv = ie.reversed.func(e, rhs)
+
+ # return conditions under which the value is
+ # valid, too.
+ beginning_denoms = denoms(ie.lhs) | denoms(ie.rhs)
+ current_denoms = denoms(rv)
+ for d in beginning_denoms - current_denoms:
+ c = _solve_inequality(Eq(d, 0), s, linear=linear)
+ if isinstance(c, Eq) and c.lhs == s:
+ if classify(rv, s, c.rhs) is S.true:
+ # rv is permitting this value but it shouldn't
+ conds.append(~c)
+ for i in (-oo, oo):
+ if (classify(rv, s, i) is S.true and
+ classify(ie, s, i) is not S.true):
+ conds.append(s < i if i is oo else i < s)
+
+ conds.append(rv)
+ return And(*conds)
+
+
+def _reduce_inequalities(inequalities, symbols):
+ # helper for reduce_inequalities
+
+ poly_part, abs_part = {}, {}
+ other = []
+
+ for inequality in inequalities:
+
+ expr, rel = inequality.lhs, inequality.rel_op # rhs is 0
+
+ # check for gens using atoms which is more strict than free_symbols to
+ # guard against EX domain which won't be handled by
+ # reduce_rational_inequalities
+ gens = expr.atoms(Symbol)
+
+ if len(gens) == 1:
+ gen = gens.pop()
+ else:
+ common = expr.free_symbols & symbols
+ if len(common) == 1:
+ gen = common.pop()
+ other.append(_solve_inequality(Relational(expr, 0, rel), gen))
+ continue
+ else:
+ raise NotImplementedError(filldedent('''
+ inequality has more than one symbol of interest.
+ '''))
+
+ if expr.is_polynomial(gen):
+ poly_part.setdefault(gen, []).append((expr, rel))
+ else:
+ components = expr.find(lambda u:
+ u.has(gen) and (
+ u.is_Function or u.is_Pow and not u.exp.is_Integer))
+ if components and all(isinstance(i, Abs) for i in components):
+ abs_part.setdefault(gen, []).append((expr, rel))
+ else:
+ other.append(_solve_inequality(Relational(expr, 0, rel), gen))
+
+ poly_reduced = [reduce_rational_inequalities([exprs], gen) for gen, exprs in poly_part.items()]
+ abs_reduced = [reduce_abs_inequalities(exprs, gen) for gen, exprs in abs_part.items()]
+
+ return And(*(poly_reduced + abs_reduced + other))
+
+
+def reduce_inequalities(inequalities, symbols=[]):
+ """Reduce a system of inequalities with rational coefficients.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import x, y
+ >>> from sympy import reduce_inequalities
+
+ >>> reduce_inequalities(0 <= x + 3, [])
+ (-3 <= x) & (x < oo)
+
+ >>> reduce_inequalities(0 <= x + y*2 - 1, [x])
+ (x < oo) & (x >= 1 - 2*y)
+ """
+ if not iterable(inequalities):
+ inequalities = [inequalities]
+ inequalities = [sympify(i) for i in inequalities]
+
+ gens = set().union(*[i.free_symbols for i in inequalities])
+
+ if not iterable(symbols):
+ symbols = [symbols]
+ symbols = (set(symbols) or gens) & gens
+ if any(i.is_extended_real is False for i in symbols):
+ raise TypeError(filldedent('''
+ inequalities cannot contain symbols that are not real.
+ '''))
+
+ # make vanilla symbol real
+ recast = {i: Dummy(i.name, extended_real=True)
+ for i in gens if i.is_extended_real is None}
+ inequalities = [i.xreplace(recast) for i in inequalities]
+ symbols = {i.xreplace(recast) for i in symbols}
+
+ # prefilter
+ keep = []
+ for i in inequalities:
+ if isinstance(i, Relational):
+ i = i.func(i.lhs.as_expr() - i.rhs.as_expr(), 0)
+ elif i not in (True, False):
+ i = Eq(i, 0)
+ if i == True:
+ continue
+ elif i == False:
+ return S.false
+ if i.lhs.is_number:
+ raise NotImplementedError(
+ "could not determine truth value of %s" % i)
+ keep.append(i)
+ inequalities = keep
+ del keep
+
+ # solve system
+ rv = _reduce_inequalities(inequalities, symbols)
+
+ # restore original symbols and return
+ return rv.xreplace({v: k for k, v in recast.items()})
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/__init__.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b543425251dea6380a1860279cb6d636f3dd629
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/__init__.py
@@ -0,0 +1,16 @@
+from .ode import (allhints, checkinfsol, classify_ode,
+ constantsimp, dsolve, homogeneous_order)
+
+from .lie_group import infinitesimals
+
+from .subscheck import checkodesol
+
+from .systems import (canonical_odes, linear_ode_to_matrix,
+ linodesolve)
+
+
+__all__ = [
+ 'allhints', 'checkinfsol', 'checkodesol', 'classify_ode', 'constantsimp',
+ 'dsolve', 'homogeneous_order', 'infinitesimals', 'canonical_odes', 'linear_ode_to_matrix',
+ 'linodesolve'
+]
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/hypergeometric.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/hypergeometric.py
new file mode 100644
index 0000000000000000000000000000000000000000..51a40b1cba32eabbdb120f9c4d5e3fd05dc644eb
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/hypergeometric.py
@@ -0,0 +1,272 @@
+r'''
+This module contains the implementation of the 2nd_hypergeometric hint for
+dsolve. This is an incomplete implementation of the algorithm described in [1].
+The algorithm solves 2nd order linear ODEs of the form
+
+.. math:: y'' + A(x) y' + B(x) y = 0\text{,}
+
+where `A` and `B` are rational functions. The algorithm should find any
+solution of the form
+
+.. math:: y = P(x) _pF_q(..; ..;\frac{\alpha x^k + \beta}{\gamma x^k + \delta})\text{,}
+
+where pFq is any of 2F1, 1F1 or 0F1 and `P` is an "arbitrary function".
+Currently only the 2F1 case is implemented in SymPy but the other cases are
+described in the paper and could be implemented in future (contributions
+welcome!).
+
+References
+==========
+
+.. [1] L. Chan, E.S. Cheb-Terrab, Non-Liouvillian solutions for second order
+ linear ODEs, (2004).
+ https://arxiv.org/abs/math-ph/0402063
+'''
+
+from sympy.core import S, Pow
+from sympy.core.function import expand
+from sympy.core.relational import Eq
+from sympy.core.symbol import Symbol, Wild
+from sympy.functions import exp, sqrt, hyper
+from sympy.integrals import Integral
+from sympy.polys import roots, gcd
+from sympy.polys.polytools import cancel, factor
+from sympy.simplify import collect, simplify, logcombine # type: ignore
+from sympy.simplify.powsimp import powdenest
+from sympy.solvers.ode.ode import get_numbered_constants
+
+
+def match_2nd_hypergeometric(eq, func):
+ x = func.args[0]
+ df = func.diff(x)
+ a3 = Wild('a3', exclude=[func, func.diff(x), func.diff(x, 2)])
+ b3 = Wild('b3', exclude=[func, func.diff(x), func.diff(x, 2)])
+ c3 = Wild('c3', exclude=[func, func.diff(x), func.diff(x, 2)])
+ deq = a3*(func.diff(x, 2)) + b3*df + c3*func
+ r = collect(eq,
+ [func.diff(x, 2), func.diff(x), func]).match(deq)
+ if r:
+ if not all(val.is_polynomial() for val in r.values()):
+ n, d = eq.as_numer_denom()
+ eq = expand(n)
+ r = collect(eq, [func.diff(x, 2), func.diff(x), func]).match(deq)
+
+ if r and r[a3]!=0:
+ A = cancel(r[b3]/r[a3])
+ B = cancel(r[c3]/r[a3])
+ return [A, B]
+ else:
+ return []
+
+
+def equivalence_hypergeometric(A, B, func):
+ # This method for finding the equivalence is only for 2F1 type.
+ # We can extend it for 1F1 and 0F1 type also.
+ x = func.args[0]
+
+ # making given equation in normal form
+ I1 = factor(cancel(A.diff(x)/2 + A**2/4 - B))
+
+ # computing shifted invariant(J1) of the equation
+ J1 = factor(cancel(x**2*I1 + S(1)/4))
+ num, dem = J1.as_numer_denom()
+ num = powdenest(expand(num))
+ dem = powdenest(expand(dem))
+ # this function will compute the different powers of variable(x) in J1.
+ # then it will help in finding value of k. k is power of x such that we can express
+ # J1 = x**k * J0(x**k) then all the powers in J0 become integers.
+ def _power_counting(num):
+ _pow = {0}
+ for val in num:
+ if val.has(x):
+ if isinstance(val, Pow) and val.as_base_exp()[0] == x:
+ _pow.add(val.as_base_exp()[1])
+ elif val == x:
+ _pow.add(val.as_base_exp()[1])
+ else:
+ _pow.update(_power_counting(val.args))
+ return _pow
+
+ pow_num = _power_counting((num, ))
+ pow_dem = _power_counting((dem, ))
+ pow_dem.update(pow_num)
+
+ _pow = pow_dem
+ k = gcd(_pow)
+
+ # computing I0 of the given equation
+ I0 = powdenest(simplify(factor(((J1/k**2) - S(1)/4)/((x**k)**2))), force=True)
+ I0 = factor(cancel(powdenest(I0.subs(x, x**(S(1)/k)), force=True)))
+
+ # Before this point I0, J1 might be functions of e.g. sqrt(x) but replacing
+ # x with x**(1/k) should result in I0 being a rational function of x or
+ # otherwise the hypergeometric solver cannot be used. Note that k can be a
+ # non-integer rational such as 2/7.
+ if not I0.is_rational_function(x):
+ return None
+
+ num, dem = I0.as_numer_denom()
+
+ max_num_pow = max(_power_counting((num, )))
+ dem_args = dem.args
+ sing_point = []
+ dem_pow = []
+ # calculating singular point of I0.
+ for arg in dem_args:
+ if arg.has(x):
+ if isinstance(arg, Pow):
+ # (x-a)**n
+ dem_pow.append(arg.as_base_exp()[1])
+ sing_point.append(list(roots(arg.as_base_exp()[0], x).keys())[0])
+ else:
+ # (x-a) type
+ dem_pow.append(arg.as_base_exp()[1])
+ sing_point.append(list(roots(arg, x).keys())[0])
+
+ dem_pow.sort()
+ # checking if equivalence is exists or not.
+
+ if equivalence(max_num_pow, dem_pow) == "2F1":
+ return {'I0':I0, 'k':k, 'sing_point':sing_point, 'type':"2F1"}
+ else:
+ return None
+
+
+def match_2nd_2F1_hypergeometric(I, k, sing_point, func):
+ x = func.args[0]
+ a = Wild("a")
+ b = Wild("b")
+ c = Wild("c")
+ t = Wild("t")
+ s = Wild("s")
+ r = Wild("r")
+ alpha = Wild("alpha")
+ beta = Wild("beta")
+ gamma = Wild("gamma")
+ delta = Wild("delta")
+ # I0 of the standerd 2F1 equation.
+ I0 = ((a-b+1)*(a-b-1)*x**2 + 2*((1-a-b)*c + 2*a*b)*x + c*(c-2))/(4*x**2*(x-1)**2)
+ if sing_point != [0, 1]:
+ # If singular point is [0, 1] then we have standerd equation.
+ eqs = []
+ sing_eqs = [-beta/alpha, -delta/gamma, (delta-beta)/(alpha-gamma)]
+ # making equations for the finding the mobius transformation
+ for i in range(3):
+ if i>> from sympy import Function, Eq, pprint
+ >>> from sympy.abc import x, y
+ >>> xi, eta, h = map(Function, ['xi', 'eta', 'h'])
+ >>> h = h(x, y) # dy/dx = h
+ >>> eta = eta(x, y)
+ >>> xi = xi(x, y)
+ >>> genform = Eq(eta.diff(x) + (eta.diff(y) - xi.diff(x))*h
+ ... - (xi.diff(y))*h**2 - xi*(h.diff(x)) - eta*(h.diff(y)), 0)
+ >>> pprint(genform)
+ /d d \ d 2 d
+ |--(eta(x, y)) - --(xi(x, y))|*h(x, y) - eta(x, y)*--(h(x, y)) - h (x, y)*--(x
+ \dy dx / dy dy
+
+ d d
+ i(x, y)) - xi(x, y)*--(h(x, y)) + --(eta(x, y)) = 0
+ dx dx
+
+ Solving the above mentioned PDE is not trivial, and can be solved only by
+ making intelligent assumptions for `\xi` and `\eta` (heuristics). Once an
+ infinitesimal is found, the attempt to find more heuristics stops. This is done to
+ optimise the speed of solving the differential equation. If a list of all the
+ infinitesimals is needed, ``hint`` should be flagged as ``all``, which gives
+ the complete list of infinitesimals. If the infinitesimals for a particular
+ heuristic needs to be found, it can be passed as a flag to ``hint``.
+
+ Examples
+ ========
+
+ >>> from sympy import Function
+ >>> from sympy.solvers.ode.lie_group import infinitesimals
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> eq = f(x).diff(x) - x**2*f(x)
+ >>> infinitesimals(eq)
+ [{eta(x, f(x)): exp(x**3/3), xi(x, f(x)): 0}]
+
+ References
+ ==========
+
+ - Solving differential equations by Symmetry Groups,
+ John Starrett, pp. 1 - pp. 14
+
+ """
+
+ if isinstance(eq, Equality):
+ eq = eq.lhs - eq.rhs
+ if not func:
+ eq, func = _preprocess(eq)
+ variables = func.args
+ if len(variables) != 1:
+ raise ValueError("ODE's have only one independent variable")
+ else:
+ x = variables[0]
+ if not order:
+ order = ode_order(eq, func)
+ if order != 1:
+ raise NotImplementedError("Infinitesimals for only "
+ "first order ODE's have been implemented")
+ else:
+ df = func.diff(x)
+ # Matching differential equation of the form a*df + b
+ a = Wild('a', exclude = [df])
+ b = Wild('b', exclude = [df])
+ if match: # Used by lie_group hint
+ h = match['h']
+ y = match['y']
+ else:
+ match = collect(expand(eq), df).match(a*df + b)
+ if match:
+ h = -simplify(match[b]/match[a])
+ else:
+ try:
+ sol = solve(eq, df)
+ except NotImplementedError:
+ raise NotImplementedError("Infinitesimals for the "
+ "first order ODE could not be found")
+ else:
+ h = sol[0] # Find infinitesimals for one solution
+ y = Dummy("y")
+ h = h.subs(func, y)
+
+ u = Dummy("u")
+ hx = h.diff(x)
+ hy = h.diff(y)
+ hinv = ((1/h).subs([(x, u), (y, x)])).subs(u, y) # Inverse ODE
+ match = {'h': h, 'func': func, 'hx': hx, 'hy': hy, 'y': y, 'hinv': hinv}
+ if hint == 'all':
+ xieta = []
+ for heuristic in lie_heuristics:
+ function = globals()['lie_heuristic_' + heuristic]
+ inflist = function(match, comp=True)
+ if inflist:
+ xieta.extend([inf for inf in inflist if inf not in xieta])
+ if xieta:
+ return xieta
+ else:
+ raise NotImplementedError("Infinitesimals could not be found for "
+ "the given ODE")
+
+ elif hint == 'default':
+ for heuristic in lie_heuristics:
+ function = globals()['lie_heuristic_' + heuristic]
+ xieta = function(match, comp=False)
+ if xieta:
+ return xieta
+
+ raise NotImplementedError("Infinitesimals could not be found for"
+ " the given ODE")
+
+ elif hint not in lie_heuristics:
+ raise ValueError("Heuristic not recognized: " + hint)
+
+ else:
+ function = globals()['lie_heuristic_' + hint]
+ xieta = function(match, comp=True)
+ if xieta:
+ return xieta
+ else:
+ raise ValueError("Infinitesimals could not be found using the"
+ " given heuristic")
+
+
+def lie_heuristic_abaco1_simple(match, comp=False):
+ r"""
+ The first heuristic uses the following four sets of
+ assumptions on `\xi` and `\eta`
+
+ .. math:: \xi = 0, \eta = f(x)
+
+ .. math:: \xi = 0, \eta = f(y)
+
+ .. math:: \xi = f(x), \eta = 0
+
+ .. math:: \xi = f(y), \eta = 0
+
+ The success of this heuristic is determined by algebraic factorisation.
+ For the first assumption `\xi = 0` and `\eta` to be a function of `x`, the PDE
+
+ .. math:: \frac{\partial \eta}{\partial x} + (\frac{\partial \eta}{\partial y}
+ - \frac{\partial \xi}{\partial x})*h
+ - \frac{\partial \xi}{\partial y}*h^{2}
+ - \xi*\frac{\partial h}{\partial x} - \eta*\frac{\partial h}{\partial y} = 0
+
+ reduces to `f'(x) - f\frac{\partial h}{\partial y} = 0`
+ If `\frac{\partial h}{\partial y}` is a function of `x`, then this can usually
+ be integrated easily. A similar idea is applied to the other 3 assumptions as well.
+
+
+ References
+ ==========
+
+ - E.S Cheb-Terrab, L.G.S Duarte and L.A,C.P da Mota, Computer Algebra
+ Solving of First Order ODEs Using Symmetry Methods, pp. 8
+
+
+ """
+
+ xieta = []
+ y = match['y']
+ h = match['h']
+ func = match['func']
+ x = func.args[0]
+ hx = match['hx']
+ hy = match['hy']
+ xi = Function('xi')(x, func)
+ eta = Function('eta')(x, func)
+
+ hysym = hy.free_symbols
+ if y not in hysym:
+ try:
+ fx = exp(integrate(hy, x))
+ except NotImplementedError:
+ pass
+ else:
+ inf = {xi: S.Zero, eta: fx}
+ if not comp:
+ return [inf]
+ if comp and inf not in xieta:
+ xieta.append(inf)
+
+ factor = hy/h
+ facsym = factor.free_symbols
+ if x not in facsym:
+ try:
+ fy = exp(integrate(factor, y))
+ except NotImplementedError:
+ pass
+ else:
+ inf = {xi: S.Zero, eta: fy.subs(y, func)}
+ if not comp:
+ return [inf]
+ if comp and inf not in xieta:
+ xieta.append(inf)
+
+ factor = -hx/h
+ facsym = factor.free_symbols
+ if y not in facsym:
+ try:
+ fx = exp(integrate(factor, x))
+ except NotImplementedError:
+ pass
+ else:
+ inf = {xi: fx, eta: S.Zero}
+ if not comp:
+ return [inf]
+ if comp and inf not in xieta:
+ xieta.append(inf)
+
+ factor = -hx/(h**2)
+ facsym = factor.free_symbols
+ if x not in facsym:
+ try:
+ fy = exp(integrate(factor, y))
+ except NotImplementedError:
+ pass
+ else:
+ inf = {xi: fy.subs(y, func), eta: S.Zero}
+ if not comp:
+ return [inf]
+ if comp and inf not in xieta:
+ xieta.append(inf)
+
+ if xieta:
+ return xieta
+
+def lie_heuristic_abaco1_product(match, comp=False):
+ r"""
+ The second heuristic uses the following two assumptions on `\xi` and `\eta`
+
+ .. math:: \eta = 0, \xi = f(x)*g(y)
+
+ .. math:: \eta = f(x)*g(y), \xi = 0
+
+ The first assumption of this heuristic holds good if
+ `\frac{1}{h^{2}}\frac{\partial^2}{\partial x \partial y}\log(h)` is
+ separable in `x` and `y`, then the separated factors containing `x`
+ is `f(x)`, and `g(y)` is obtained by
+
+ .. math:: e^{\int f\frac{\partial}{\partial x}\left(\frac{1}{f*h}\right)\,dy}
+
+ provided `f\frac{\partial}{\partial x}\left(\frac{1}{f*h}\right)` is a function
+ of `y` only.
+
+ The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as
+ `\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first assumption
+ satisfies. After obtaining `f(x)` and `g(y)`, the coordinates are again
+ interchanged, to get `\eta` as `f(x)*g(y)`
+
+
+ References
+ ==========
+ - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+ ODE Patterns, pp. 7 - pp. 8
+
+ """
+
+ xieta = []
+ y = match['y']
+ h = match['h']
+ hinv = match['hinv']
+ func = match['func']
+ x = func.args[0]
+ xi = Function('xi')(x, func)
+ eta = Function('eta')(x, func)
+
+
+ inf = separatevars(((log(h).diff(y)).diff(x))/h**2, dict=True, symbols=[x, y])
+ if inf and inf['coeff']:
+ fx = inf[x]
+ gy = simplify(fx*((1/(fx*h)).diff(x)))
+ gysyms = gy.free_symbols
+ if x not in gysyms:
+ gy = exp(integrate(gy, y))
+ inf = {eta: S.Zero, xi: (fx*gy).subs(y, func)}
+ if not comp:
+ return [inf]
+ if comp and inf not in xieta:
+ xieta.append(inf)
+
+ u1 = Dummy("u1")
+ inf = separatevars(((log(hinv).diff(y)).diff(x))/hinv**2, dict=True, symbols=[x, y])
+ if inf and inf['coeff']:
+ fx = inf[x]
+ gy = simplify(fx*((1/(fx*hinv)).diff(x)))
+ gysyms = gy.free_symbols
+ if x not in gysyms:
+ gy = exp(integrate(gy, y))
+ etaval = fx*gy
+ etaval = (etaval.subs([(x, u1), (y, x)])).subs(u1, y)
+ inf = {eta: etaval.subs(y, func), xi: S.Zero}
+ if not comp:
+ return [inf]
+ if comp and inf not in xieta:
+ xieta.append(inf)
+
+ if xieta:
+ return xieta
+
+def lie_heuristic_bivariate(match, comp=False):
+ r"""
+ The third heuristic assumes the infinitesimals `\xi` and `\eta`
+ to be bi-variate polynomials in `x` and `y`. The assumption made here
+ for the logic below is that `h` is a rational function in `x` and `y`
+ though that may not be necessary for the infinitesimals to be
+ bivariate polynomials. The coefficients of the infinitesimals
+ are found out by substituting them in the PDE and grouping similar terms
+ that are polynomials and since they form a linear system, solve and check
+ for non trivial solutions. The degree of the assumed bivariates
+ are increased till a certain maximum value.
+
+ References
+ ==========
+ - Lie Groups and Differential Equations
+ pp. 327 - pp. 329
+
+ """
+
+ h = match['h']
+ hx = match['hx']
+ hy = match['hy']
+ func = match['func']
+ x = func.args[0]
+ y = match['y']
+ xi = Function('xi')(x, func)
+ eta = Function('eta')(x, func)
+
+ if h.is_rational_function():
+ # The maximum degree that the infinitesimals can take is
+ # calculated by this technique.
+ etax, etay, etad, xix, xiy, xid = symbols("etax etay etad xix xiy xid")
+ ipde = etax + (etay - xix)*h - xiy*h**2 - xid*hx - etad*hy
+ num, denom = cancel(ipde).as_numer_denom()
+ deg = Poly(num, x, y).total_degree()
+ deta = Function('deta')(x, y)
+ dxi = Function('dxi')(x, y)
+ ipde = (deta.diff(x) + (deta.diff(y) - dxi.diff(x))*h - (dxi.diff(y))*h**2
+ - dxi*hx - deta*hy)
+ xieq = Symbol("xi0")
+ etaeq = Symbol("eta0")
+
+ for i in range(deg + 1):
+ if i:
+ xieq += Add(*[
+ Symbol("xi_" + str(power) + "_" + str(i - power))*x**power*y**(i - power)
+ for power in range(i + 1)])
+ etaeq += Add(*[
+ Symbol("eta_" + str(power) + "_" + str(i - power))*x**power*y**(i - power)
+ for power in range(i + 1)])
+ pden, denom = (ipde.subs({dxi: xieq, deta: etaeq}).doit()).as_numer_denom()
+ pden = expand(pden)
+
+ # If the individual terms are monomials, the coefficients
+ # are grouped
+ if pden.is_polynomial(x, y) and pden.is_Add:
+ polyy = Poly(pden, x, y).as_dict()
+ if polyy:
+ symset = xieq.free_symbols.union(etaeq.free_symbols) - {x, y}
+ soldict = solve(polyy.values(), *symset)
+ if isinstance(soldict, list):
+ soldict = soldict[0]
+ if any(soldict.values()):
+ xired = xieq.subs(soldict)
+ etared = etaeq.subs(soldict)
+ # Scaling is done by substituting one for the parameters
+ # This can be any number except zero.
+ dict_ = {sym: 1 for sym in symset}
+ inf = {eta: etared.subs(dict_).subs(y, func),
+ xi: xired.subs(dict_).subs(y, func)}
+ return [inf]
+
+def lie_heuristic_chi(match, comp=False):
+ r"""
+ The aim of the fourth heuristic is to find the function `\chi(x, y)`
+ that satisfies the PDE `\frac{d\chi}{dx} + h\frac{d\chi}{dx}
+ - \frac{\partial h}{\partial y}\chi = 0`.
+
+ This assumes `\chi` to be a bivariate polynomial in `x` and `y`. By intuition,
+ `h` should be a rational function in `x` and `y`. The method used here is
+ to substitute a general binomial for `\chi` up to a certain maximum degree
+ is reached. The coefficients of the polynomials, are calculated by by collecting
+ terms of the same order in `x` and `y`.
+
+ After finding `\chi`, the next step is to use `\eta = \xi*h + \chi`, to
+ determine `\xi` and `\eta`. This can be done by dividing `\chi` by `h`
+ which would give `-\xi` as the quotient and `\eta` as the remainder.
+
+
+ References
+ ==========
+ - E.S Cheb-Terrab, L.G.S Duarte and L.A,C.P da Mota, Computer Algebra
+ Solving of First Order ODEs Using Symmetry Methods, pp. 8
+
+ """
+
+ h = match['h']
+ hy = match['hy']
+ func = match['func']
+ x = func.args[0]
+ y = match['y']
+ xi = Function('xi')(x, func)
+ eta = Function('eta')(x, func)
+
+ if h.is_rational_function():
+ schi, schix, schiy = symbols("schi, schix, schiy")
+ cpde = schix + h*schiy - hy*schi
+ num, denom = cancel(cpde).as_numer_denom()
+ deg = Poly(num, x, y).total_degree()
+
+ chi = Function('chi')(x, y)
+ chix = chi.diff(x)
+ chiy = chi.diff(y)
+ cpde = chix + h*chiy - hy*chi
+ chieq = Symbol("chi")
+ for i in range(1, deg + 1):
+ chieq += Add(*[
+ Symbol("chi_" + str(power) + "_" + str(i - power))*x**power*y**(i - power)
+ for power in range(i + 1)])
+ cnum, cden = cancel(cpde.subs({chi : chieq}).doit()).as_numer_denom()
+ cnum = expand(cnum)
+ if cnum.is_polynomial(x, y) and cnum.is_Add:
+ cpoly = Poly(cnum, x, y).as_dict()
+ if cpoly:
+ solsyms = chieq.free_symbols - {x, y}
+ soldict = solve(cpoly.values(), *solsyms)
+ if isinstance(soldict, list):
+ soldict = soldict[0]
+ if any(soldict.values()):
+ chieq = chieq.subs(soldict)
+ dict_ = {sym: 1 for sym in solsyms}
+ chieq = chieq.subs(dict_)
+ # After finding chi, the main aim is to find out
+ # eta, xi by the equation eta = xi*h + chi
+ # One method to set xi, would be rearranging it to
+ # (eta/h) - xi = (chi/h). This would mean dividing
+ # chi by h would give -xi as the quotient and eta
+ # as the remainder. Thanks to Sean Vig for suggesting
+ # this method.
+ xic, etac = div(chieq, h)
+ inf = {eta: etac.subs(y, func), xi: -xic.subs(y, func)}
+ return [inf]
+
+def lie_heuristic_function_sum(match, comp=False):
+ r"""
+ This heuristic uses the following two assumptions on `\xi` and `\eta`
+
+ .. math:: \eta = 0, \xi = f(x) + g(y)
+
+ .. math:: \eta = f(x) + g(y), \xi = 0
+
+ The first assumption of this heuristic holds good if
+
+ .. math:: \frac{\partial}{\partial y}[(h\frac{\partial^{2}}{
+ \partial x^{2}}(h^{-1}))^{-1}]
+
+ is separable in `x` and `y`,
+
+ 1. The separated factors containing `y` is `\frac{\partial g}{\partial y}`.
+ From this `g(y)` can be determined.
+ 2. The separated factors containing `x` is `f''(x)`.
+ 3. `h\frac{\partial^{2}}{\partial x^{2}}(h^{-1})` equals
+ `\frac{f''(x)}{f(x) + g(y)}`. From this `f(x)` can be determined.
+
+ The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as
+ `\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first
+ assumption satisfies. After obtaining `f(x)` and `g(y)`, the coordinates
+ are again interchanged, to get `\eta` as `f(x) + g(y)`.
+
+ For both assumptions, the constant factors are separated among `g(y)`
+ and `f''(x)`, such that `f''(x)` obtained from 3] is the same as that
+ obtained from 2]. If not possible, then this heuristic fails.
+
+
+ References
+ ==========
+ - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+ ODE Patterns, pp. 7 - pp. 8
+
+ """
+
+ xieta = []
+ h = match['h']
+ func = match['func']
+ hinv = match['hinv']
+ x = func.args[0]
+ y = match['y']
+ xi = Function('xi')(x, func)
+ eta = Function('eta')(x, func)
+
+ for odefac in [h, hinv]:
+ factor = odefac*((1/odefac).diff(x, 2))
+ sep = separatevars((1/factor).diff(y), dict=True, symbols=[x, y])
+ if sep and sep['coeff'] and sep[x].has(x) and sep[y].has(y):
+ k = Dummy("k")
+ try:
+ gy = k*integrate(sep[y], y)
+ except NotImplementedError:
+ pass
+ else:
+ fdd = 1/(k*sep[x]*sep['coeff'])
+ fx = simplify(fdd/factor - gy)
+ check = simplify(fx.diff(x, 2) - fdd)
+ if fx:
+ if not check:
+ fx = fx.subs(k, 1)
+ gy = (gy/k)
+ else:
+ sol = solve(check, k)
+ if sol:
+ sol = sol[0]
+ fx = fx.subs(k, sol)
+ gy = (gy/k)*sol
+ else:
+ continue
+ if odefac == hinv: # Inverse ODE
+ fx = fx.subs(x, y)
+ gy = gy.subs(y, x)
+ etaval = factor_terms(fx + gy)
+ if etaval.is_Mul:
+ etaval = Mul(*[arg for arg in etaval.args if arg.has(x, y)])
+ if odefac == hinv: # Inverse ODE
+ inf = {eta: etaval.subs(y, func), xi : S.Zero}
+ else:
+ inf = {xi: etaval.subs(y, func), eta : S.Zero}
+ if not comp:
+ return [inf]
+ else:
+ xieta.append(inf)
+
+ if xieta:
+ return xieta
+
+def lie_heuristic_abaco2_similar(match, comp=False):
+ r"""
+ This heuristic uses the following two assumptions on `\xi` and `\eta`
+
+ .. math:: \eta = g(x), \xi = f(x)
+
+ .. math:: \eta = f(y), \xi = g(y)
+
+ For the first assumption,
+
+ 1. First `\frac{\frac{\partial h}{\partial y}}{\frac{\partial^{2} h}{
+ \partial yy}}` is calculated. Let us say this value is A
+
+ 2. If this is constant, then `h` is matched to the form `A(x) + B(x)e^{
+ \frac{y}{C}}` then, `\frac{e^{\int \frac{A(x)}{C} \,dx}}{B(x)}` gives `f(x)`
+ and `A(x)*f(x)` gives `g(x)`
+
+ 3. Otherwise `\frac{\frac{\partial A}{\partial X}}{\frac{\partial A}{
+ \partial Y}} = \gamma` is calculated. If
+
+ a] `\gamma` is a function of `x` alone
+
+ b] `\frac{\gamma\frac{\partial h}{\partial y} - \gamma'(x) - \frac{
+ \partial h}{\partial x}}{h + \gamma} = G` is a function of `x` alone.
+ then, `e^{\int G \,dx}` gives `f(x)` and `-\gamma*f(x)` gives `g(x)`
+
+ The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as
+ `\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first assumption
+ satisfies. After obtaining `f(x)` and `g(x)`, the coordinates are again
+ interchanged, to get `\xi` as `f(x^*)` and `\eta` as `g(y^*)`
+
+ References
+ ==========
+ - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+ ODE Patterns, pp. 10 - pp. 12
+
+ """
+
+ h = match['h']
+ hx = match['hx']
+ hy = match['hy']
+ func = match['func']
+ hinv = match['hinv']
+ x = func.args[0]
+ y = match['y']
+ xi = Function('xi')(x, func)
+ eta = Function('eta')(x, func)
+
+ factor = cancel(h.diff(y)/h.diff(y, 2))
+ factorx = factor.diff(x)
+ factory = factor.diff(y)
+ if not factor.has(x) and not factor.has(y):
+ A = Wild('A', exclude=[y])
+ B = Wild('B', exclude=[y])
+ C = Wild('C', exclude=[x, y])
+ match = h.match(A + B*exp(y/C))
+ try:
+ tau = exp(-integrate(match[A]/match[C]), x)/match[B]
+ except NotImplementedError:
+ pass
+ else:
+ gx = match[A]*tau
+ return [{xi: tau, eta: gx}]
+
+ else:
+ gamma = cancel(factorx/factory)
+ if not gamma.has(y):
+ tauint = cancel((gamma*hy - gamma.diff(x) - hx)/(h + gamma))
+ if not tauint.has(y):
+ try:
+ tau = exp(integrate(tauint, x))
+ except NotImplementedError:
+ pass
+ else:
+ gx = -tau*gamma
+ return [{xi: tau, eta: gx}]
+
+ factor = cancel(hinv.diff(y)/hinv.diff(y, 2))
+ factorx = factor.diff(x)
+ factory = factor.diff(y)
+ if not factor.has(x) and not factor.has(y):
+ A = Wild('A', exclude=[y])
+ B = Wild('B', exclude=[y])
+ C = Wild('C', exclude=[x, y])
+ match = h.match(A + B*exp(y/C))
+ try:
+ tau = exp(-integrate(match[A]/match[C]), x)/match[B]
+ except NotImplementedError:
+ pass
+ else:
+ gx = match[A]*tau
+ return [{eta: tau.subs(x, func), xi: gx.subs(x, func)}]
+
+ else:
+ gamma = cancel(factorx/factory)
+ if not gamma.has(y):
+ tauint = cancel((gamma*hinv.diff(y) - gamma.diff(x) - hinv.diff(x))/(
+ hinv + gamma))
+ if not tauint.has(y):
+ try:
+ tau = exp(integrate(tauint, x))
+ except NotImplementedError:
+ pass
+ else:
+ gx = -tau*gamma
+ return [{eta: tau.subs(x, func), xi: gx.subs(x, func)}]
+
+
+def lie_heuristic_abaco2_unique_unknown(match, comp=False):
+ r"""
+ This heuristic assumes the presence of unknown functions or known functions
+ with non-integer powers.
+
+ 1. A list of all functions and non-integer powers containing x and y
+ 2. Loop over each element `f` in the list, find `\frac{\frac{\partial f}{\partial x}}{
+ \frac{\partial f}{\partial x}} = R`
+
+ If it is separable in `x` and `y`, let `X` be the factors containing `x`. Then
+
+ a] Check if `\xi = X` and `\eta = -\frac{X}{R}` satisfy the PDE. If yes, then return
+ `\xi` and `\eta`
+ b] Check if `\xi = \frac{-R}{X}` and `\eta = -\frac{1}{X}` satisfy the PDE.
+ If yes, then return `\xi` and `\eta`
+
+ If not, then check if
+
+ a] :math:`\xi = -R,\eta = 1`
+
+ b] :math:`\xi = 1, \eta = -\frac{1}{R}`
+
+ are solutions.
+
+ References
+ ==========
+ - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+ ODE Patterns, pp. 10 - pp. 12
+
+ """
+
+ h = match['h']
+ hx = match['hx']
+ hy = match['hy']
+ func = match['func']
+ x = func.args[0]
+ y = match['y']
+ xi = Function('xi')(x, func)
+ eta = Function('eta')(x, func)
+
+ funclist = []
+ for atom in h.atoms(Pow):
+ base, exp = atom.as_base_exp()
+ if base.has(x) and base.has(y):
+ if not exp.is_Integer:
+ funclist.append(atom)
+
+ for function in h.atoms(AppliedUndef):
+ syms = function.free_symbols
+ if x in syms and y in syms:
+ funclist.append(function)
+
+ for f in funclist:
+ frac = cancel(f.diff(y)/f.diff(x))
+ sep = separatevars(frac, dict=True, symbols=[x, y])
+ if sep and sep['coeff']:
+ xitry1 = sep[x]
+ etatry1 = -1/(sep[y]*sep['coeff'])
+ pde1 = etatry1.diff(y)*h - xitry1.diff(x)*h - xitry1*hx - etatry1*hy
+ if not simplify(pde1):
+ return [{xi: xitry1, eta: etatry1.subs(y, func)}]
+ xitry2 = 1/etatry1
+ etatry2 = 1/xitry1
+ pde2 = etatry2.diff(x) - (xitry2.diff(y))*h**2 - xitry2*hx - etatry2*hy
+ if not simplify(expand(pde2)):
+ return [{xi: xitry2.subs(y, func), eta: etatry2}]
+
+ else:
+ etatry = -1/frac
+ pde = etatry.diff(x) + etatry.diff(y)*h - hx - etatry*hy
+ if not simplify(pde):
+ return [{xi: S.One, eta: etatry.subs(y, func)}]
+ xitry = -frac
+ pde = -xitry.diff(x)*h -xitry.diff(y)*h**2 - xitry*hx -hy
+ if not simplify(expand(pde)):
+ return [{xi: xitry.subs(y, func), eta: S.One}]
+
+
+def lie_heuristic_abaco2_unique_general(match, comp=False):
+ r"""
+ This heuristic finds if infinitesimals of the form `\eta = f(x)`, `\xi = g(y)`
+ without making any assumptions on `h`.
+
+ The complete sequence of steps is given in the paper mentioned below.
+
+ References
+ ==========
+ - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+ ODE Patterns, pp. 10 - pp. 12
+
+ """
+ hx = match['hx']
+ hy = match['hy']
+ func = match['func']
+ x = func.args[0]
+ y = match['y']
+ xi = Function('xi')(x, func)
+ eta = Function('eta')(x, func)
+
+ A = hx.diff(y)
+ B = hy.diff(y) + hy**2
+ C = hx.diff(x) - hx**2
+
+ if not (A and B and C):
+ return
+
+ Ax = A.diff(x)
+ Ay = A.diff(y)
+ Axy = Ax.diff(y)
+ Axx = Ax.diff(x)
+ Ayy = Ay.diff(y)
+ D = simplify(2*Axy + hx*Ay - Ax*hy + (hx*hy + 2*A)*A)*A - 3*Ax*Ay
+ if not D:
+ E1 = simplify(3*Ax**2 + ((hx**2 + 2*C)*A - 2*Axx)*A)
+ if E1:
+ E2 = simplify((2*Ayy + (2*B - hy**2)*A)*A - 3*Ay**2)
+ if not E2:
+ E3 = simplify(
+ E1*((28*Ax + 4*hx*A)*A**3 - E1*(hy*A + Ay)) - E1.diff(x)*8*A**4)
+ if not E3:
+ etaval = cancel((4*A**3*(Ax - hx*A) + E1*(hy*A - Ay))/(S(2)*A*E1))
+ if x not in etaval:
+ try:
+ etaval = exp(integrate(etaval, y))
+ except NotImplementedError:
+ pass
+ else:
+ xival = -4*A**3*etaval/E1
+ if y not in xival:
+ return [{xi: xival, eta: etaval.subs(y, func)}]
+
+ else:
+ E1 = simplify((2*Ayy + (2*B - hy**2)*A)*A - 3*Ay**2)
+ if E1:
+ E2 = simplify(
+ 4*A**3*D - D**2 + E1*((2*Axx - (hx**2 + 2*C)*A)*A - 3*Ax**2))
+ if not E2:
+ E3 = simplify(
+ -(A*D)*E1.diff(y) + ((E1.diff(x) - hy*D)*A + 3*Ay*D +
+ (A*hx - 3*Ax)*E1)*E1)
+ if not E3:
+ etaval = cancel(((A*hx - Ax)*E1 - (Ay + A*hy)*D)/(S(2)*A*D))
+ if x not in etaval:
+ try:
+ etaval = exp(integrate(etaval, y))
+ except NotImplementedError:
+ pass
+ else:
+ xival = -E1*etaval/D
+ if y not in xival:
+ return [{xi: xival, eta: etaval.subs(y, func)}]
+
+
+def lie_heuristic_linear(match, comp=False):
+ r"""
+ This heuristic assumes
+
+ 1. `\xi = ax + by + c` and
+ 2. `\eta = fx + gy + h`
+
+ After substituting the following assumptions in the determining PDE, it
+ reduces to
+
+ .. math:: f + (g - a)h - bh^{2} - (ax + by + c)\frac{\partial h}{\partial x}
+ - (fx + gy + c)\frac{\partial h}{\partial y}
+
+ Solving the reduced PDE obtained, using the method of characteristics, becomes
+ impractical. The method followed is grouping similar terms and solving the system
+ of linear equations obtained. The difference between the bivariate heuristic is that
+ `h` need not be a rational function in this case.
+
+ References
+ ==========
+ - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+ ODE Patterns, pp. 10 - pp. 12
+
+ """
+ h = match['h']
+ hx = match['hx']
+ hy = match['hy']
+ func = match['func']
+ x = func.args[0]
+ y = match['y']
+ xi = Function('xi')(x, func)
+ eta = Function('eta')(x, func)
+
+ coeffdict = {}
+ symbols = numbered_symbols("c", cls=Dummy)
+ symlist = [next(symbols) for _ in islice(symbols, 6)]
+ C0, C1, C2, C3, C4, C5 = symlist
+ pde = C3 + (C4 - C0)*h - (C0*x + C1*y + C2)*hx - (C3*x + C4*y + C5)*hy - C1*h**2
+ pde, denom = pde.as_numer_denom()
+ pde = powsimp(expand(pde))
+ if pde.is_Add:
+ terms = pde.args
+ for term in terms:
+ if term.is_Mul:
+ rem = Mul(*[m for m in term.args if not m.has(x, y)])
+ xypart = term/rem
+ if xypart not in coeffdict:
+ coeffdict[xypart] = rem
+ else:
+ coeffdict[xypart] += rem
+ else:
+ if term not in coeffdict:
+ coeffdict[term] = S.One
+ else:
+ coeffdict[term] += S.One
+
+ sollist = coeffdict.values()
+ soldict = solve(sollist, symlist)
+ if soldict:
+ if isinstance(soldict, list):
+ soldict = soldict[0]
+ subval = soldict.values()
+ if any(t for t in subval):
+ onedict = dict(zip(symlist, [1]*6))
+ xival = C0*x + C1*func + C2
+ etaval = C3*x + C4*func + C5
+ xival = xival.subs(soldict)
+ etaval = etaval.subs(soldict)
+ xival = xival.subs(onedict)
+ etaval = etaval.subs(onedict)
+ return [{xi: xival, eta: etaval}]
+
+
+def _lie_group_remove(coords):
+ r"""
+ This function is strictly meant for internal use by the Lie group ODE solving
+ method. It replaces arbitrary functions returned by pdsolve as follows:
+
+ 1] If coords is an arbitrary function, then its argument is returned.
+ 2] An arbitrary function in an Add object is replaced by zero.
+ 3] An arbitrary function in a Mul object is replaced by one.
+ 4] If there is no arbitrary function coords is returned unchanged.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.ode.lie_group import _lie_group_remove
+ >>> from sympy import Function
+ >>> from sympy.abc import x, y
+ >>> F = Function("F")
+ >>> eq = x**2*y
+ >>> _lie_group_remove(eq)
+ x**2*y
+ >>> eq = F(x**2*y)
+ >>> _lie_group_remove(eq)
+ x**2*y
+ >>> eq = x*y**2 + F(x**3)
+ >>> _lie_group_remove(eq)
+ x*y**2
+ >>> eq = (F(x**3) + y)*x**4
+ >>> _lie_group_remove(eq)
+ x**4*y
+
+ """
+ if isinstance(coords, AppliedUndef):
+ return coords.args[0]
+ elif coords.is_Add:
+ subfunc = coords.atoms(AppliedUndef)
+ if subfunc:
+ for func in subfunc:
+ coords = coords.subs(func, 0)
+ return coords
+ elif coords.is_Pow:
+ base, expr = coords.as_base_exp()
+ base = _lie_group_remove(base)
+ expr = _lie_group_remove(expr)
+ return base**expr
+ elif coords.is_Mul:
+ mulargs = []
+ coordargs = coords.args
+ for arg in coordargs:
+ if not isinstance(coords, AppliedUndef):
+ mulargs.append(_lie_group_remove(arg))
+ return Mul(*mulargs)
+ return coords
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/nonhomogeneous.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/nonhomogeneous.py
new file mode 100644
index 0000000000000000000000000000000000000000..87ff54074871f76304a60ec0e46aa3ff999df9ec
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/nonhomogeneous.py
@@ -0,0 +1,499 @@
+r"""
+This File contains helper functions for nth_linear_constant_coeff_undetermined_coefficients,
+nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients,
+nth_linear_constant_coeff_variation_of_parameters,
+and nth_linear_euler_eq_nonhomogeneous_variation_of_parameters.
+
+All the functions in this file are used by more than one solvers so, instead of creating
+instances in other classes for using them it is better to keep it here as separate helpers.
+
+"""
+from collections import defaultdict
+from sympy.core import Add, S
+from sympy.core.function import diff, expand, _mexpand, expand_mul
+from sympy.core.relational import Eq
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import Dummy, Wild
+from sympy.functions import exp, cos, cosh, im, log, re, sin, sinh, \
+ atan2, conjugate
+from sympy.integrals import Integral
+from sympy.polys import (Poly, RootOf, rootof, roots)
+from sympy.simplify import collect, simplify, separatevars, powsimp, trigsimp # type: ignore
+from sympy.utilities import numbered_symbols
+from sympy.solvers.solvers import solve
+from sympy.matrices import wronskian
+from .subscheck import sub_func_doit
+from sympy.solvers.ode.ode import get_numbered_constants
+
+
+def _test_term(coeff, func, order):
+ r"""
+ Linear Euler ODEs have the form K*x**order*diff(y(x), x, order) = F(x),
+ where K is independent of x and y(x), order>= 0.
+ So we need to check that for each term, coeff == K*x**order from
+ some K. We have a few cases, since coeff may have several
+ different types.
+ """
+ x = func.args[0]
+ f = func.func
+ if order < 0:
+ raise ValueError("order should be greater than 0")
+ if coeff == 0:
+ return True
+ if order == 0:
+ if x in coeff.free_symbols:
+ return False
+ return True
+ if coeff.is_Mul:
+ if coeff.has(f(x)):
+ return False
+ return x**order in coeff.args
+ elif coeff.is_Pow:
+ return coeff.as_base_exp() == (x, order)
+ elif order == 1:
+ return x == coeff
+ return False
+
+
+def _get_euler_characteristic_eq_sols(eq, func, match_obj):
+ r"""
+ Returns the solution of homogeneous part of the linear euler ODE and
+ the list of roots of characteristic equation.
+
+ The parameter ``match_obj`` is a dict of order:coeff terms, where order is the order
+ of the derivative on each term, and coeff is the coefficient of that derivative.
+
+ """
+ x = func.args[0]
+ f = func.func
+
+ # First, set up characteristic equation.
+ chareq, symbol = S.Zero, Dummy('x')
+
+ for i in match_obj:
+ if i >= 0:
+ chareq += (match_obj[i]*diff(x**symbol, x, i)*x**-symbol).expand()
+
+ chareq = Poly(chareq, symbol)
+ chareqroots = [rootof(chareq, k) for k in range(chareq.degree())]
+ collectterms = []
+
+ # A generator of constants
+ constants = list(get_numbered_constants(eq, num=chareq.degree()*2))
+ constants.reverse()
+
+ # Create a dict root: multiplicity or charroots
+ charroots = defaultdict(int)
+ for root in chareqroots:
+ charroots[root] += 1
+ gsol = S.Zero
+ ln = log
+ for root, multiplicity in charroots.items():
+ for i in range(multiplicity):
+ if isinstance(root, RootOf):
+ gsol += (x**root) * constants.pop()
+ if multiplicity != 1:
+ raise ValueError("Value should be 1")
+ collectterms = [(0, root, 0)] + collectterms
+ elif root.is_real:
+ gsol += ln(x)**i*(x**root) * constants.pop()
+ collectterms = [(i, root, 0)] + collectterms
+ else:
+ reroot = re(root)
+ imroot = im(root)
+ gsol += ln(x)**i * (x**reroot) * (
+ constants.pop() * sin(abs(imroot)*ln(x))
+ + constants.pop() * cos(imroot*ln(x)))
+ collectterms = [(i, reroot, imroot)] + collectterms
+
+ gsol = Eq(f(x), gsol)
+
+ gensols = []
+ # Keep track of when to use sin or cos for nonzero imroot
+ for i, reroot, imroot in collectterms:
+ if imroot == 0:
+ gensols.append(ln(x)**i*x**reroot)
+ else:
+ sin_form = ln(x)**i*x**reroot*sin(abs(imroot)*ln(x))
+ if sin_form in gensols:
+ cos_form = ln(x)**i*x**reroot*cos(imroot*ln(x))
+ gensols.append(cos_form)
+ else:
+ gensols.append(sin_form)
+ return gsol, gensols
+
+
+def _solve_variation_of_parameters(eq, func, roots, homogen_sol, order, match_obj, simplify_flag=True):
+ r"""
+ Helper function for the method of variation of parameters and nonhomogeneous euler eq.
+
+ See the
+ :py:meth:`~sympy.solvers.ode.single.NthLinearConstantCoeffVariationOfParameters`
+ docstring for more information on this method.
+
+ The parameter are ``match_obj`` should be a dictionary that has the following
+ keys:
+
+ ``list``
+ A list of solutions to the homogeneous equation.
+
+ ``sol``
+ The general solution.
+
+ """
+ f = func.func
+ x = func.args[0]
+ r = match_obj
+ psol = 0
+ wr = wronskian(roots, x)
+
+ if simplify_flag:
+ wr = simplify(wr) # We need much better simplification for
+ # some ODEs. See issue 4662, for example.
+ # To reduce commonly occurring sin(x)**2 + cos(x)**2 to 1
+ wr = trigsimp(wr, deep=True, recursive=True)
+ if not wr:
+ # The wronskian will be 0 iff the solutions are not linearly
+ # independent.
+ raise NotImplementedError("Cannot find " + str(order) +
+ " solutions to the homogeneous equation necessary to apply " +
+ "variation of parameters to " + str(eq) + " (Wronskian == 0)")
+ if len(roots) != order:
+ raise NotImplementedError("Cannot find " + str(order) +
+ " solutions to the homogeneous equation necessary to apply " +
+ "variation of parameters to " +
+ str(eq) + " (number of terms != order)")
+ negoneterm = S.NegativeOne**(order)
+ for i in roots:
+ psol += negoneterm*Integral(wronskian([sol for sol in roots if sol != i], x)*r[-1]/wr, x)*i/r[order]
+ negoneterm *= -1
+
+ if simplify_flag:
+ psol = simplify(psol)
+ psol = trigsimp(psol, deep=True)
+ return Eq(f(x), homogen_sol.rhs + psol)
+
+
+def _get_const_characteristic_eq_sols(r, func, order):
+ r"""
+ Returns the roots of characteristic equation of constant coefficient
+ linear ODE and list of collectterms which is later on used by simplification
+ to use collect on solution.
+
+ The parameter `r` is a dict of order:coeff terms, where order is the order of the
+ derivative on each term, and coeff is the coefficient of that derivative.
+
+ """
+ x = func.args[0]
+ # First, set up characteristic equation.
+ chareq, symbol = S.Zero, Dummy('x')
+
+ for i in r.keys():
+ if isinstance(i, str) or i < 0:
+ pass
+ else:
+ chareq += r[i]*symbol**i
+
+ chareq = Poly(chareq, symbol)
+ # Can't just call roots because it doesn't return rootof for unsolveable
+ # polynomials.
+ chareqroots = roots(chareq, multiple=True)
+ if len(chareqroots) != order:
+ chareqroots = [rootof(chareq, k) for k in range(chareq.degree())]
+
+ chareq_is_complex = not all(i.is_real for i in chareq.all_coeffs())
+
+ # Create a dict root: multiplicity or charroots
+ charroots = defaultdict(int)
+ for root in chareqroots:
+ charroots[root] += 1
+ # We need to keep track of terms so we can run collect() at the end.
+ # This is necessary for constantsimp to work properly.
+ collectterms = []
+ gensols = []
+ conjugate_roots = [] # used to prevent double-use of conjugate roots
+ # Loop over roots in theorder provided by roots/rootof...
+ for root in chareqroots:
+ # but don't repoeat multiple roots.
+ if root not in charroots:
+ continue
+ multiplicity = charroots.pop(root)
+ for i in range(multiplicity):
+ if chareq_is_complex:
+ gensols.append(x**i*exp(root*x))
+ collectterms = [(i, root, 0)] + collectterms
+ continue
+ reroot = re(root)
+ imroot = im(root)
+ if imroot.has(atan2) and reroot.has(atan2):
+ # Remove this condition when re and im stop returning
+ # circular atan2 usages.
+ gensols.append(x**i*exp(root*x))
+ collectterms = [(i, root, 0)] + collectterms
+ else:
+ if root in conjugate_roots:
+ collectterms = [(i, reroot, imroot)] + collectterms
+ continue
+ if imroot == 0:
+ gensols.append(x**i*exp(reroot*x))
+ collectterms = [(i, reroot, 0)] + collectterms
+ continue
+ conjugate_roots.append(conjugate(root))
+ gensols.append(x**i*exp(reroot*x) * sin(abs(imroot) * x))
+ gensols.append(x**i*exp(reroot*x) * cos( imroot * x))
+
+ # This ordering is important
+ collectterms = [(i, reroot, imroot)] + collectterms
+ return gensols, collectterms
+
+
+# Ideally these kind of simplification functions shouldn't be part of solvers.
+# odesimp should be improved to handle these kind of specific simplifications.
+def _get_simplified_sol(sol, func, collectterms):
+ r"""
+ Helper function which collects the solution on
+ collectterms. Ideally this should be handled by odesimp.It is used
+ only when the simplify is set to True in dsolve.
+
+ The parameter ``collectterms`` is a list of tuple (i, reroot, imroot) where `i` is
+ the multiplicity of the root, reroot is real part and imroot being the imaginary part.
+
+ """
+ f = func.func
+ x = func.args[0]
+ collectterms.sort(key=default_sort_key)
+ collectterms.reverse()
+ assert len(sol) == 1 and sol[0].lhs == f(x)
+ sol = sol[0].rhs
+ sol = expand_mul(sol)
+ for i, reroot, imroot in collectterms:
+ sol = collect(sol, x**i*exp(reroot*x)*sin(abs(imroot)*x))
+ sol = collect(sol, x**i*exp(reroot*x)*cos(imroot*x))
+ for i, reroot, imroot in collectterms:
+ sol = collect(sol, x**i*exp(reroot*x))
+ sol = powsimp(sol)
+ return Eq(f(x), sol)
+
+
+def _undetermined_coefficients_match(expr, x, func=None, eq_homogeneous=S.Zero):
+ r"""
+ Returns a trial function match if undetermined coefficients can be applied
+ to ``expr``, and ``None`` otherwise.
+
+ A trial expression can be found for an expression for use with the method
+ of undetermined coefficients if the expression is an
+ additive/multiplicative combination of constants, polynomials in `x` (the
+ independent variable of expr), `\sin(a x + b)`, `\cos(a x + b)`, and
+ `e^{a x}` terms (in other words, it has a finite number of linearly
+ independent derivatives).
+
+ Note that you may still need to multiply each term returned here by
+ sufficient `x` to make it linearly independent with the solutions to the
+ homogeneous equation.
+
+ This is intended for internal use by ``undetermined_coefficients`` hints.
+
+ SymPy currently has no way to convert `\sin^n(x) \cos^m(y)` into a sum of
+ only `\sin(a x)` and `\cos(b x)` terms, so these are not implemented. So,
+ for example, you will need to manually convert `\sin^2(x)` into `[1 +
+ \cos(2 x)]/2` to properly apply the method of undetermined coefficients on
+ it.
+
+ Examples
+ ========
+
+ >>> from sympy import log, exp
+ >>> from sympy.solvers.ode.nonhomogeneous import _undetermined_coefficients_match
+ >>> from sympy.abc import x
+ >>> _undetermined_coefficients_match(9*x*exp(x) + exp(-x), x)
+ {'test': True, 'trialset': {x*exp(x), exp(-x), exp(x)}}
+ >>> _undetermined_coefficients_match(log(x), x)
+ {'test': False}
+
+ """
+ a = Wild('a', exclude=[x])
+ b = Wild('b', exclude=[x])
+ expr = powsimp(expr, combine='exp') # exp(x)*exp(2*x + 1) => exp(3*x + 1)
+ retdict = {}
+
+ def _test_term(expr, x):
+ r"""
+ Test if ``expr`` fits the proper form for undetermined coefficients.
+ """
+ if not expr.has(x):
+ return True
+ elif expr.is_Add:
+ return all(_test_term(i, x) for i in expr.args)
+ elif expr.is_Mul:
+ if expr.has(sin, cos):
+ foundtrig = False
+ # Make sure that there is only one trig function in the args.
+ # See the docstring.
+ for i in expr.args:
+ if i.has(sin, cos):
+ if foundtrig:
+ return False
+ else:
+ foundtrig = True
+ return all(_test_term(i, x) for i in expr.args)
+ elif expr.is_Function:
+ if expr.func in (sin, cos, exp, sinh, cosh):
+ if expr.args[0].match(a*x + b):
+ return True
+ else:
+ return False
+ else:
+ return False
+ elif expr.is_Pow and expr.base.is_Symbol and expr.exp.is_Integer and \
+ expr.exp >= 0:
+ return True
+ elif expr.is_Pow and expr.base.is_number:
+ if expr.exp.match(a*x + b):
+ return True
+ else:
+ return False
+ elif expr.is_Symbol or expr.is_number:
+ return True
+ else:
+ return False
+
+ def _get_trial_set(expr, x, exprs=set()):
+ r"""
+ Returns a set of trial terms for undetermined coefficients.
+
+ The idea behind undetermined coefficients is that the terms expression
+ repeat themselves after a finite number of derivatives, except for the
+ coefficients (they are linearly dependent). So if we collect these,
+ we should have the terms of our trial function.
+ """
+ def _remove_coefficient(expr, x):
+ r"""
+ Returns the expression without a coefficient.
+
+ Similar to expr.as_independent(x)[1], except it only works
+ multiplicatively.
+ """
+ term = S.One
+ if expr.is_Mul:
+ for i in expr.args:
+ if i.has(x):
+ term *= i
+ elif expr.has(x):
+ term = expr
+ return term
+
+ expr = expand_mul(expr)
+ if expr.is_Add:
+ for term in expr.args:
+ if _remove_coefficient(term, x) in exprs:
+ pass
+ else:
+ exprs.add(_remove_coefficient(term, x))
+ exprs = exprs.union(_get_trial_set(term, x, exprs))
+ else:
+ term = _remove_coefficient(expr, x)
+ tmpset = exprs.union({term})
+ oldset = set()
+ while tmpset != oldset:
+ # If you get stuck in this loop, then _test_term is probably
+ # broken
+ oldset = tmpset.copy()
+ expr = expr.diff(x)
+ term = _remove_coefficient(expr, x)
+ if term.is_Add:
+ tmpset = tmpset.union(_get_trial_set(term, x, tmpset))
+ else:
+ tmpset.add(term)
+ exprs = tmpset
+ return exprs
+
+ def is_homogeneous_solution(term):
+ r""" This function checks whether the given trialset contains any root
+ of homogeneous equation"""
+ return expand(sub_func_doit(eq_homogeneous, func, term)).is_zero
+
+ retdict['test'] = _test_term(expr, x)
+ if retdict['test']:
+ # Try to generate a list of trial solutions that will have the
+ # undetermined coefficients. Note that if any of these are not linearly
+ # independent with any of the solutions to the homogeneous equation,
+ # then they will need to be multiplied by sufficient x to make them so.
+ # This function DOES NOT do that (it doesn't even look at the
+ # homogeneous equation).
+ temp_set = set()
+ for i in Add.make_args(expr):
+ act = _get_trial_set(i, x)
+ if eq_homogeneous is not S.Zero:
+ while any(is_homogeneous_solution(ts) for ts in act):
+ act = {x*ts for ts in act}
+ temp_set = temp_set.union(act)
+
+ retdict['trialset'] = temp_set
+ return retdict
+
+
+def _solve_undetermined_coefficients(eq, func, order, match, trialset):
+ r"""
+ Helper function for the method of undetermined coefficients.
+
+ See the
+ :py:meth:`~sympy.solvers.ode.single.NthLinearConstantCoeffUndeterminedCoefficients`
+ docstring for more information on this method.
+
+ The parameter ``trialset`` is the set of trial functions as returned by
+ ``_undetermined_coefficients_match()['trialset']``.
+
+ The parameter ``match`` should be a dictionary that has the following
+ keys:
+
+ ``list``
+ A list of solutions to the homogeneous equation.
+
+ ``sol``
+ The general solution.
+
+ """
+ r = match
+ coeffs = numbered_symbols('a', cls=Dummy)
+ coefflist = []
+ gensols = r['list']
+ gsol = r['sol']
+ f = func.func
+ x = func.args[0]
+
+ if len(gensols) != order:
+ raise NotImplementedError("Cannot find " + str(order) +
+ " solutions to the homogeneous equation necessary to apply" +
+ " undetermined coefficients to " + str(eq) +
+ " (number of terms != order)")
+
+ trialfunc = 0
+ for i in trialset:
+ c = next(coeffs)
+ coefflist.append(c)
+ trialfunc += c*i
+
+ eqs = sub_func_doit(eq, f(x), trialfunc)
+
+ coeffsdict = dict(list(zip(trialset, [0]*(len(trialset) + 1))))
+
+ eqs = _mexpand(eqs)
+
+ for i in Add.make_args(eqs):
+ s = separatevars(i, dict=True, symbols=[x])
+ if coeffsdict.get(s[x]):
+ coeffsdict[s[x]] += s['coeff']
+ else:
+ coeffsdict[s[x]] = s['coeff']
+
+ coeffvals = solve(list(coeffsdict.values()), coefflist)
+
+ if not coeffvals:
+ raise NotImplementedError(
+ "Could not solve `%s` using the "
+ "method of undetermined coefficients "
+ "(unable to solve for coefficients)." % eq)
+
+ psol = trialfunc.subs(coeffvals)
+
+ return Eq(f(x), gsol.rhs + psol)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/ode.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/ode.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4f01d91177c5f00951c681d159cd52abbddf7fc
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/ode.py
@@ -0,0 +1,3563 @@
+r"""
+This module contains :py:meth:`~sympy.solvers.ode.dsolve` and different helper
+functions that it uses.
+
+:py:meth:`~sympy.solvers.ode.dsolve` solves ordinary differential equations.
+See the docstring on the various functions for their uses. Note that partial
+differential equations support is in ``pde.py``. Note that hint functions
+have docstrings describing their various methods, but they are intended for
+internal use. Use ``dsolve(ode, func, hint=hint)`` to solve an ODE using a
+specific hint. See also the docstring on
+:py:meth:`~sympy.solvers.ode.dsolve`.
+
+**Functions in this module**
+
+ These are the user functions in this module:
+
+ - :py:meth:`~sympy.solvers.ode.dsolve` - Solves ODEs.
+ - :py:meth:`~sympy.solvers.ode.classify_ode` - Classifies ODEs into
+ possible hints for :py:meth:`~sympy.solvers.ode.dsolve`.
+ - :py:meth:`~sympy.solvers.ode.checkodesol` - Checks if an equation is the
+ solution to an ODE.
+ - :py:meth:`~sympy.solvers.ode.homogeneous_order` - Returns the
+ homogeneous order of an expression.
+ - :py:meth:`~sympy.solvers.ode.infinitesimals` - Returns the infinitesimals
+ of the Lie group of point transformations of an ODE, such that it is
+ invariant.
+ - :py:meth:`~sympy.solvers.ode.checkinfsol` - Checks if the given infinitesimals
+ are the actual infinitesimals of a first order ODE.
+
+ These are the non-solver helper functions that are for internal use. The
+ user should use the various options to
+ :py:meth:`~sympy.solvers.ode.dsolve` to obtain the functionality provided
+ by these functions:
+
+ - :py:meth:`~sympy.solvers.ode.ode.odesimp` - Does all forms of ODE
+ simplification.
+ - :py:meth:`~sympy.solvers.ode.ode.ode_sol_simplicity` - A key function for
+ comparing solutions by simplicity.
+ - :py:meth:`~sympy.solvers.ode.constantsimp` - Simplifies arbitrary
+ constants.
+ - :py:meth:`~sympy.solvers.ode.ode.constant_renumber` - Renumber arbitrary
+ constants.
+ - :py:meth:`~sympy.solvers.ode.ode._handle_Integral` - Evaluate unevaluated
+ Integrals.
+
+ See also the docstrings of these functions.
+
+**Currently implemented solver methods**
+
+The following methods are implemented for solving ordinary differential
+equations. See the docstrings of the various hint functions for more
+information on each (run ``help(ode)``):
+
+ - 1st order separable differential equations.
+ - 1st order differential equations whose coefficients or `dx` and `dy` are
+ functions homogeneous of the same order.
+ - 1st order exact differential equations.
+ - 1st order linear differential equations.
+ - 1st order Bernoulli differential equations.
+ - Power series solutions for first order differential equations.
+ - Lie Group method of solving first order differential equations.
+ - 2nd order Liouville differential equations.
+ - Power series solutions for second order differential equations
+ at ordinary and regular singular points.
+ - `n`\th order differential equation that can be solved with algebraic
+ rearrangement and integration.
+ - `n`\th order linear homogeneous differential equation with constant
+ coefficients.
+ - `n`\th order linear inhomogeneous differential equation with constant
+ coefficients using the method of undetermined coefficients.
+ - `n`\th order linear inhomogeneous differential equation with constant
+ coefficients using the method of variation of parameters.
+
+**Philosophy behind this module**
+
+This module is designed to make it easy to add new ODE solving methods without
+having to mess with the solving code for other methods. The idea is that
+there is a :py:meth:`~sympy.solvers.ode.classify_ode` function, which takes in
+an ODE and tells you what hints, if any, will solve the ODE. It does this
+without attempting to solve the ODE, so it is fast. Each solving method is a
+hint, and it has its own function, named ``ode_``. That function takes
+in the ODE and any match expression gathered by
+:py:meth:`~sympy.solvers.ode.classify_ode` and returns a solved result. If
+this result has any integrals in it, the hint function will return an
+unevaluated :py:class:`~sympy.integrals.integrals.Integral` class.
+:py:meth:`~sympy.solvers.ode.dsolve`, which is the user wrapper function
+around all of this, will then call :py:meth:`~sympy.solvers.ode.ode.odesimp` on
+the result, which, among other things, will attempt to solve the equation for
+the dependent variable (the function we are solving for), simplify the
+arbitrary constants in the expression, and evaluate any integrals, if the hint
+allows it.
+
+**How to add new solution methods**
+
+If you have an ODE that you want :py:meth:`~sympy.solvers.ode.dsolve` to be
+able to solve, try to avoid adding special case code here. Instead, try
+finding a general method that will solve your ODE, as well as others. This
+way, the :py:mod:`~sympy.solvers.ode` module will become more robust, and
+unhindered by special case hacks. WolphramAlpha and Maple's
+DETools[odeadvisor] function are two resources you can use to classify a
+specific ODE. It is also better for a method to work with an `n`\th order ODE
+instead of only with specific orders, if possible.
+
+To add a new method, there are a few things that you need to do. First, you
+need a hint name for your method. Try to name your hint so that it is
+unambiguous with all other methods, including ones that may not be implemented
+yet. If your method uses integrals, also include a ``hint_Integral`` hint.
+If there is more than one way to solve ODEs with your method, include a hint
+for each one, as well as a ``_best`` hint. Your ``ode__best()``
+function should choose the best using min with ``ode_sol_simplicity`` as the
+key argument. See
+:obj:`~sympy.solvers.ode.single.HomogeneousCoeffBest`, for example.
+The function that uses your method will be called ``ode_()``, so the
+hint must only use characters that are allowed in a Python function name
+(alphanumeric characters and the underscore '``_``' character). Include a
+function for every hint, except for ``_Integral`` hints
+(:py:meth:`~sympy.solvers.ode.dsolve` takes care of those automatically).
+Hint names should be all lowercase, unless a word is commonly capitalized
+(such as Integral or Bernoulli). If you have a hint that you do not want to
+run with ``all_Integral`` that does not have an ``_Integral`` counterpart (such
+as a best hint that would defeat the purpose of ``all_Integral``), you will
+need to remove it manually in the :py:meth:`~sympy.solvers.ode.dsolve` code.
+See also the :py:meth:`~sympy.solvers.ode.classify_ode` docstring for
+guidelines on writing a hint name.
+
+Determine *in general* how the solutions returned by your method compare with
+other methods that can potentially solve the same ODEs. Then, put your hints
+in the :py:data:`~sympy.solvers.ode.allhints` tuple in the order that they
+should be called. The ordering of this tuple determines which hints are
+default. Note that exceptions are ok, because it is easy for the user to
+choose individual hints with :py:meth:`~sympy.solvers.ode.dsolve`. In
+general, ``_Integral`` variants should go at the end of the list, and
+``_best`` variants should go before the various hints they apply to. For
+example, the ``undetermined_coefficients`` hint comes before the
+``variation_of_parameters`` hint because, even though variation of parameters
+is more general than undetermined coefficients, undetermined coefficients
+generally returns cleaner results for the ODEs that it can solve than
+variation of parameters does, and it does not require integration, so it is
+much faster.
+
+Next, you need to have a match expression or a function that matches the type
+of the ODE, which you should put in :py:meth:`~sympy.solvers.ode.classify_ode`
+(if the match function is more than just a few lines. It should match the
+ODE without solving for it as much as possible, so that
+:py:meth:`~sympy.solvers.ode.classify_ode` remains fast and is not hindered by
+bugs in solving code. Be sure to consider corner cases. For example, if your
+solution method involves dividing by something, make sure you exclude the case
+where that division will be 0.
+
+In most cases, the matching of the ODE will also give you the various parts
+that you need to solve it. You should put that in a dictionary (``.match()``
+will do this for you), and add that as ``matching_hints['hint'] = matchdict``
+in the relevant part of :py:meth:`~sympy.solvers.ode.classify_ode`.
+:py:meth:`~sympy.solvers.ode.classify_ode` will then send this to
+:py:meth:`~sympy.solvers.ode.dsolve`, which will send it to your function as
+the ``match`` argument. Your function should be named ``ode_(eq, func,
+order, match)`. If you need to send more information, put it in the ``match``
+dictionary. For example, if you had to substitute in a dummy variable in
+:py:meth:`~sympy.solvers.ode.classify_ode` to match the ODE, you will need to
+pass it to your function using the `match` dict to access it. You can access
+the independent variable using ``func.args[0]``, and the dependent variable
+(the function you are trying to solve for) as ``func.func``. If, while trying
+to solve the ODE, you find that you cannot, raise ``NotImplementedError``.
+:py:meth:`~sympy.solvers.ode.dsolve` will catch this error with the ``all``
+meta-hint, rather than causing the whole routine to fail.
+
+Add a docstring to your function that describes the method employed. Like
+with anything else in SymPy, you will need to add a doctest to the docstring,
+in addition to real tests in ``test_ode.py``. Try to maintain consistency
+with the other hint functions' docstrings. Add your method to the list at the
+top of this docstring. Also, add your method to ``ode.rst`` in the
+``docs/src`` directory, so that the Sphinx docs will pull its docstring into
+the main SymPy documentation. Be sure to make the Sphinx documentation by
+running ``make html`` from within the doc directory to verify that the
+docstring formats correctly.
+
+If your solution method involves integrating, use :py:obj:`~.Integral` instead of
+:py:meth:`~sympy.core.expr.Expr.integrate`. This allows the user to bypass
+hard/slow integration by using the ``_Integral`` variant of your hint. In
+most cases, calling :py:meth:`sympy.core.basic.Basic.doit` will integrate your
+solution. If this is not the case, you will need to write special code in
+:py:meth:`~sympy.solvers.ode.ode._handle_Integral`. Arbitrary constants should be
+symbols named ``C1``, ``C2``, and so on. All solution methods should return
+an equality instance. If you need an arbitrary number of arbitrary constants,
+you can use ``constants = numbered_symbols(prefix='C', cls=Symbol, start=1)``.
+If it is possible to solve for the dependent function in a general way, do so.
+Otherwise, do as best as you can, but do not call solve in your
+``ode_()`` function. :py:meth:`~sympy.solvers.ode.ode.odesimp` will attempt
+to solve the solution for you, so you do not need to do that. Lastly, if your
+ODE has a common simplification that can be applied to your solutions, you can
+add a special case in :py:meth:`~sympy.solvers.ode.ode.odesimp` for it. For
+example, solutions returned from the ``1st_homogeneous_coeff`` hints often
+have many :obj:`~sympy.functions.elementary.exponential.log` terms, so
+:py:meth:`~sympy.solvers.ode.ode.odesimp` calls
+:py:meth:`~sympy.simplify.simplify.logcombine` on them (it also helps to write
+the arbitrary constant as ``log(C1)`` instead of ``C1`` in this case). Also
+consider common ways that you can rearrange your solution to have
+:py:meth:`~sympy.solvers.ode.constantsimp` take better advantage of it. It is
+better to put simplification in :py:meth:`~sympy.solvers.ode.ode.odesimp` than in
+your method, because it can then be turned off with the simplify flag in
+:py:meth:`~sympy.solvers.ode.dsolve`. If you have any extraneous
+simplification in your function, be sure to only run it using ``if
+match.get('simplify', True):``, especially if it can be slow or if it can
+reduce the domain of the solution.
+
+Finally, as with every contribution to SymPy, your method will need to be
+tested. Add a test for each method in ``test_ode.py``. Follow the
+conventions there, i.e., test the solver using ``dsolve(eq, f(x),
+hint=your_hint)``, and also test the solution using
+:py:meth:`~sympy.solvers.ode.checkodesol` (you can put these in a separate
+tests and skip/XFAIL if it runs too slow/does not work). Be sure to call your
+hint specifically in :py:meth:`~sympy.solvers.ode.dsolve`, that way the test
+will not be broken simply by the introduction of another matching hint. If your
+method works for higher order (>1) ODEs, you will need to run ``sol =
+constant_renumber(sol, 'C', 1, order)`` for each solution, where ``order`` is
+the order of the ODE. This is because ``constant_renumber`` renumbers the
+arbitrary constants by printing order, which is platform dependent. Try to
+test every corner case of your solver, including a range of orders if it is a
+`n`\th order solver, but if your solver is slow, such as if it involves hard
+integration, try to keep the test run time down.
+
+Feel free to refactor existing hints to avoid duplicating code or creating
+inconsistencies. If you can show that your method exactly duplicates an
+existing method, including in the simplicity and speed of obtaining the
+solutions, then you can remove the old, less general method. The existing
+code is tested extensively in ``test_ode.py``, so if anything is broken, one
+of those tests will surely fail.
+
+"""
+
+from sympy.core import Add, S, Mul, Pow, oo
+from sympy.core.containers import Tuple
+from sympy.core.expr import AtomicExpr, Expr
+from sympy.core.function import (Function, Derivative, AppliedUndef, diff,
+ expand, expand_mul, Subs)
+from sympy.core.multidimensional import vectorize
+from sympy.core.numbers import nan, zoo, Number
+from sympy.core.relational import Equality, Eq
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.core.symbol import Symbol, Wild, Dummy, symbols
+from sympy.core.sympify import sympify
+from sympy.core.traversal import preorder_traversal
+
+from sympy.logic.boolalg import (BooleanAtom, BooleanTrue,
+ BooleanFalse)
+from sympy.functions import exp, log, sqrt
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.integrals.integrals import Integral
+from sympy.polys import (Poly, terms_gcd, PolynomialError, lcm)
+from sympy.polys.polytools import cancel
+from sympy.series import Order
+from sympy.series.series import series
+from sympy.simplify import (collect, logcombine, powsimp, # type: ignore
+ separatevars, simplify, cse)
+from sympy.simplify.radsimp import collect_const
+from sympy.solvers import checksol, solve
+
+from sympy.utilities import numbered_symbols
+from sympy.utilities.iterables import uniq, sift, iterable
+from sympy.solvers.deutils import _preprocess, ode_order, _desolve
+
+
+#: This is a list of hints in the order that they should be preferred by
+#: :py:meth:`~sympy.solvers.ode.classify_ode`. In general, hints earlier in the
+#: list should produce simpler solutions than those later in the list (for
+#: ODEs that fit both). For now, the order of this list is based on empirical
+#: observations by the developers of SymPy.
+#:
+#: The hint used by :py:meth:`~sympy.solvers.ode.dsolve` for a specific ODE
+#: can be overridden (see the docstring).
+#:
+#: In general, ``_Integral`` hints are grouped at the end of the list, unless
+#: there is a method that returns an unevaluable integral most of the time
+#: (which go near the end of the list anyway). ``default``, ``all``,
+#: ``best``, and ``all_Integral`` meta-hints should not be included in this
+#: list, but ``_best`` and ``_Integral`` hints should be included.
+allhints = (
+ "factorable",
+ "nth_algebraic",
+ "separable",
+ "1st_exact",
+ "1st_linear",
+ "Bernoulli",
+ "1st_rational_riccati",
+ "Riccati_special_minus2",
+ "1st_homogeneous_coeff_best",
+ "1st_homogeneous_coeff_subs_indep_div_dep",
+ "1st_homogeneous_coeff_subs_dep_div_indep",
+ "almost_linear",
+ "linear_coefficients",
+ "separable_reduced",
+ "1st_power_series",
+ "lie_group",
+ "nth_linear_constant_coeff_homogeneous",
+ "nth_linear_euler_eq_homogeneous",
+ "nth_linear_constant_coeff_undetermined_coefficients",
+ "nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients",
+ "nth_linear_constant_coeff_variation_of_parameters",
+ "nth_linear_euler_eq_nonhomogeneous_variation_of_parameters",
+ "Liouville",
+ "2nd_linear_airy",
+ "2nd_linear_bessel",
+ "2nd_hypergeometric",
+ "2nd_hypergeometric_Integral",
+ "nth_order_reducible",
+ "2nd_power_series_ordinary",
+ "2nd_power_series_regular",
+ "nth_algebraic_Integral",
+ "separable_Integral",
+ "1st_exact_Integral",
+ "1st_linear_Integral",
+ "Bernoulli_Integral",
+ "1st_homogeneous_coeff_subs_indep_div_dep_Integral",
+ "1st_homogeneous_coeff_subs_dep_div_indep_Integral",
+ "almost_linear_Integral",
+ "linear_coefficients_Integral",
+ "separable_reduced_Integral",
+ "nth_linear_constant_coeff_variation_of_parameters_Integral",
+ "nth_linear_euler_eq_nonhomogeneous_variation_of_parameters_Integral",
+ "Liouville_Integral",
+ "2nd_nonlinear_autonomous_conserved",
+ "2nd_nonlinear_autonomous_conserved_Integral",
+ )
+
+
+
+def get_numbered_constants(eq, num=1, start=1, prefix='C'):
+ """
+ Returns a list of constants that do not occur
+ in eq already.
+ """
+
+ ncs = iter_numbered_constants(eq, start, prefix)
+ Cs = [next(ncs) for i in range(num)]
+ return (Cs[0] if num == 1 else tuple(Cs))
+
+
+def iter_numbered_constants(eq, start=1, prefix='C'):
+ """
+ Returns an iterator of constants that do not occur
+ in eq already.
+ """
+
+ if isinstance(eq, (Expr, Eq)):
+ eq = [eq]
+ elif not iterable(eq):
+ raise ValueError("Expected Expr or iterable but got %s" % eq)
+
+ atom_set = set().union(*[i.free_symbols for i in eq])
+ func_set = set().union(*[i.atoms(Function) for i in eq])
+ if func_set:
+ atom_set |= {Symbol(str(f.func)) for f in func_set}
+ return numbered_symbols(start=start, prefix=prefix, exclude=atom_set)
+
+
+def dsolve(eq, func=None, hint="default", simplify=True,
+ ics= None, xi=None, eta=None, x0=0, n=6, **kwargs):
+ r"""
+ Solves any (supported) kind of ordinary differential equation and
+ system of ordinary differential equations.
+
+ For single ordinary differential equation
+ =========================================
+
+ It is classified under this when number of equation in ``eq`` is one.
+ **Usage**
+
+ ``dsolve(eq, f(x), hint)`` -> Solve ordinary differential equation
+ ``eq`` for function ``f(x)``, using method ``hint``.
+
+ **Details**
+
+ ``eq`` can be any supported ordinary differential equation (see the
+ :py:mod:`~sympy.solvers.ode` docstring for supported methods).
+ This can either be an :py:class:`~sympy.core.relational.Equality`,
+ or an expression, which is assumed to be equal to ``0``.
+
+ ``f(x)`` is a function of one variable whose derivatives in that
+ variable make up the ordinary differential equation ``eq``. In
+ many cases it is not necessary to provide this; it will be
+ autodetected (and an error raised if it could not be detected).
+
+ ``hint`` is the solving method that you want dsolve to use. Use
+ ``classify_ode(eq, f(x))`` to get all of the possible hints for an
+ ODE. The default hint, ``default``, will use whatever hint is
+ returned first by :py:meth:`~sympy.solvers.ode.classify_ode`. See
+ Hints below for more options that you can use for hint.
+
+ ``simplify`` enables simplification by
+ :py:meth:`~sympy.solvers.ode.ode.odesimp`. See its docstring for more
+ information. Turn this off, for example, to disable solving of
+ solutions for ``func`` or simplification of arbitrary constants.
+ It will still integrate with this hint. Note that the solution may
+ contain more arbitrary constants than the order of the ODE with
+ this option enabled.
+
+ ``xi`` and ``eta`` are the infinitesimal functions of an ordinary
+ differential equation. They are the infinitesimals of the Lie group
+ of point transformations for which the differential equation is
+ invariant. The user can specify values for the infinitesimals. If
+ nothing is specified, ``xi`` and ``eta`` are calculated using
+ :py:meth:`~sympy.solvers.ode.infinitesimals` with the help of various
+ heuristics.
+
+ ``ics`` is the set of initial/boundary conditions for the differential equation.
+ It should be given in the form of ``{f(x0): x1, f(x).diff(x).subs(x, x2):
+ x3}`` and so on. For power series solutions, if no initial
+ conditions are specified ``f(0)`` is assumed to be ``C0`` and the power
+ series solution is calculated about 0.
+
+ ``x0`` is the point about which the power series solution of a differential
+ equation is to be evaluated.
+
+ ``n`` gives the exponent of the dependent variable up to which the power series
+ solution of a differential equation is to be evaluated.
+
+ **Hints**
+
+ Aside from the various solving methods, there are also some meta-hints
+ that you can pass to :py:meth:`~sympy.solvers.ode.dsolve`:
+
+ ``default``:
+ This uses whatever hint is returned first by
+ :py:meth:`~sympy.solvers.ode.classify_ode`. This is the
+ default argument to :py:meth:`~sympy.solvers.ode.dsolve`.
+
+ ``all``:
+ To make :py:meth:`~sympy.solvers.ode.dsolve` apply all
+ relevant classification hints, use ``dsolve(ODE, func,
+ hint="all")``. This will return a dictionary of
+ ``hint:solution`` terms. If a hint causes dsolve to raise the
+ ``NotImplementedError``, value of that hint's key will be the
+ exception object raised. The dictionary will also include
+ some special keys:
+
+ - ``order``: The order of the ODE. See also
+ :py:meth:`~sympy.solvers.deutils.ode_order` in
+ ``deutils.py``.
+ - ``best``: The simplest hint; what would be returned by
+ ``best`` below.
+ - ``best_hint``: The hint that would produce the solution
+ given by ``best``. If more than one hint produces the best
+ solution, the first one in the tuple returned by
+ :py:meth:`~sympy.solvers.ode.classify_ode` is chosen.
+ - ``default``: The solution that would be returned by default.
+ This is the one produced by the hint that appears first in
+ the tuple returned by
+ :py:meth:`~sympy.solvers.ode.classify_ode`.
+
+ ``all_Integral``:
+ This is the same as ``all``, except if a hint also has a
+ corresponding ``_Integral`` hint, it only returns the
+ ``_Integral`` hint. This is useful if ``all`` causes
+ :py:meth:`~sympy.solvers.ode.dsolve` to hang because of a
+ difficult or impossible integral. This meta-hint will also be
+ much faster than ``all``, because
+ :py:meth:`~sympy.core.expr.Expr.integrate` is an expensive
+ routine.
+
+ ``best``:
+ To have :py:meth:`~sympy.solvers.ode.dsolve` try all methods
+ and return the simplest one. This takes into account whether
+ the solution is solvable in the function, whether it contains
+ any Integral classes (i.e. unevaluatable integrals), and
+ which one is the shortest in size.
+
+ See also the :py:meth:`~sympy.solvers.ode.classify_ode` docstring for
+ more info on hints, and the :py:mod:`~sympy.solvers.ode` docstring for
+ a list of all supported hints.
+
+ **Tips**
+
+ - You can declare the derivative of an unknown function this way:
+
+ >>> from sympy import Function, Derivative
+ >>> from sympy.abc import x # x is the independent variable
+ >>> f = Function("f")(x) # f is a function of x
+ >>> # f_ will be the derivative of f with respect to x
+ >>> f_ = Derivative(f, x)
+
+ - See ``test_ode.py`` for many tests, which serves also as a set of
+ examples for how to use :py:meth:`~sympy.solvers.ode.dsolve`.
+ - :py:meth:`~sympy.solvers.ode.dsolve` always returns an
+ :py:class:`~sympy.core.relational.Equality` class (except for the
+ case when the hint is ``all`` or ``all_Integral``). If possible, it
+ solves the solution explicitly for the function being solved for.
+ Otherwise, it returns an implicit solution.
+ - Arbitrary constants are symbols named ``C1``, ``C2``, and so on.
+ - Because all solutions should be mathematically equivalent, some
+ hints may return the exact same result for an ODE. Often, though,
+ two different hints will return the same solution formatted
+ differently. The two should be equivalent. Also note that sometimes
+ the values of the arbitrary constants in two different solutions may
+ not be the same, because one constant may have "absorbed" other
+ constants into it.
+ - Do ``help(ode.ode_)`` to get help more information on a
+ specific hint, where ```` is the name of a hint without
+ ``_Integral``.
+
+ For system of ordinary differential equations
+ =============================================
+
+ **Usage**
+ ``dsolve(eq, func)`` -> Solve a system of ordinary differential
+ equations ``eq`` for ``func`` being list of functions including
+ `x(t)`, `y(t)`, `z(t)` where number of functions in the list depends
+ upon the number of equations provided in ``eq``.
+
+ **Details**
+
+ ``eq`` can be any supported system of ordinary differential equations
+ This can either be an :py:class:`~sympy.core.relational.Equality`,
+ or an expression, which is assumed to be equal to ``0``.
+
+ ``func`` holds ``x(t)`` and ``y(t)`` being functions of one variable which
+ together with some of their derivatives make up the system of ordinary
+ differential equation ``eq``. It is not necessary to provide this; it
+ will be autodetected (and an error raised if it could not be detected).
+
+ **Hints**
+
+ The hints are formed by parameters returned by classify_sysode, combining
+ them give hints name used later for forming method name.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, Eq, Derivative, sin, cos, symbols
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> dsolve(Derivative(f(x), x, x) + 9*f(x), f(x))
+ Eq(f(x), C1*sin(3*x) + C2*cos(3*x))
+
+ >>> eq = sin(x)*cos(f(x)) + cos(x)*sin(f(x))*f(x).diff(x)
+ >>> dsolve(eq, hint='1st_exact')
+ [Eq(f(x), -acos(C1/cos(x)) + 2*pi), Eq(f(x), acos(C1/cos(x)))]
+ >>> dsolve(eq, hint='almost_linear')
+ [Eq(f(x), -acos(C1/cos(x)) + 2*pi), Eq(f(x), acos(C1/cos(x)))]
+ >>> t = symbols('t')
+ >>> x, y = symbols('x, y', cls=Function)
+ >>> eq = (Eq(Derivative(x(t),t), 12*t*x(t) + 8*y(t)), Eq(Derivative(y(t),t), 21*x(t) + 7*t*y(t)))
+ >>> dsolve(eq)
+ [Eq(x(t), C1*x0(t) + C2*x0(t)*Integral(8*exp(Integral(7*t, t))*exp(Integral(12*t, t))/x0(t)**2, t)),
+ Eq(y(t), C1*y0(t) + C2*(y0(t)*Integral(8*exp(Integral(7*t, t))*exp(Integral(12*t, t))/x0(t)**2, t) +
+ exp(Integral(7*t, t))*exp(Integral(12*t, t))/x0(t)))]
+ >>> eq = (Eq(Derivative(x(t),t),x(t)*y(t)*sin(t)), Eq(Derivative(y(t),t),y(t)**2*sin(t)))
+ >>> dsolve(eq)
+ {Eq(x(t), -exp(C1)/(C2*exp(C1) - cos(t))), Eq(y(t), -1/(C1 - cos(t)))}
+ """
+ if iterable(eq):
+ from sympy.solvers.ode.systems import dsolve_system
+
+ # This may have to be changed in future
+ # when we have weakly and strongly
+ # connected components. This have to
+ # changed to show the systems that haven't
+ # been solved.
+ try:
+ sol = dsolve_system(eq, funcs=func, ics=ics, doit=True)
+ return sol[0] if len(sol) == 1 else sol
+ except NotImplementedError:
+ pass
+
+ match = classify_sysode(eq, func)
+
+ eq = match['eq']
+ order = match['order']
+ func = match['func']
+ t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+
+ # keep highest order term coefficient positive
+ for i in range(len(eq)):
+ for func_ in func:
+ if isinstance(func_, list):
+ pass
+ else:
+ if eq[i].coeff(diff(func[i],t,ode_order(eq[i], func[i]))).is_negative:
+ eq[i] = -eq[i]
+ match['eq'] = eq
+ if len(set(order.values()))!=1:
+ raise ValueError("It solves only those systems of equations whose orders are equal")
+ match['order'] = list(order.values())[0]
+ def recur_len(l):
+ return sum(recur_len(item) if isinstance(item,list) else 1 for item in l)
+ if recur_len(func) != len(eq):
+ raise ValueError("dsolve() and classify_sysode() work with "
+ "number of functions being equal to number of equations")
+ if match['type_of_equation'] is None:
+ raise NotImplementedError
+ else:
+ if match['is_linear'] == True:
+ solvefunc = globals()['sysode_linear_%(no_of_equation)seq_order%(order)s' % match]
+ else:
+ solvefunc = globals()['sysode_nonlinear_%(no_of_equation)seq_order%(order)s' % match]
+ sols = solvefunc(match)
+ if ics:
+ constants = Tuple(*sols).free_symbols - Tuple(*eq).free_symbols
+ solved_constants = solve_ics(sols, func, constants, ics)
+ return [sol.subs(solved_constants) for sol in sols]
+ return sols
+ else:
+ given_hint = hint # hint given by the user
+
+ # See the docstring of _desolve for more details.
+ hints = _desolve(eq, func=func,
+ hint=hint, simplify=True, xi=xi, eta=eta, type='ode', ics=ics,
+ x0=x0, n=n, **kwargs)
+ eq = hints.pop('eq', eq)
+ all_ = hints.pop('all', False)
+ if all_:
+ retdict = {}
+ failed_hints = {}
+ gethints = classify_ode(eq, dict=True, hint='all')
+ orderedhints = gethints['ordered_hints']
+ for hint in hints:
+ try:
+ rv = _helper_simplify(eq, hint, hints[hint], simplify)
+ except NotImplementedError as detail:
+ failed_hints[hint] = detail
+ else:
+ retdict[hint] = rv
+ func = hints[hint]['func']
+
+ retdict['best'] = min(list(retdict.values()), key=lambda x:
+ ode_sol_simplicity(x, func, trysolving=not simplify))
+ if given_hint == 'best':
+ return retdict['best']
+ for i in orderedhints:
+ if retdict['best'] == retdict.get(i, None):
+ retdict['best_hint'] = i
+ break
+ retdict['default'] = gethints['default']
+ retdict['order'] = gethints['order']
+ retdict.update(failed_hints)
+ return retdict
+
+ else:
+ # The key 'hint' stores the hint needed to be solved for.
+ hint = hints['hint']
+ return _helper_simplify(eq, hint, hints, simplify, ics=ics)
+
+def _helper_simplify(eq, hint, match, simplify=True, ics=None, **kwargs):
+ r"""
+ Helper function of dsolve that calls the respective
+ :py:mod:`~sympy.solvers.ode` functions to solve for the ordinary
+ differential equations. This minimizes the computation in calling
+ :py:meth:`~sympy.solvers.deutils._desolve` multiple times.
+ """
+ r = match
+ func = r['func']
+ order = r['order']
+ match = r[hint]
+
+ if isinstance(match, SingleODESolver):
+ solvefunc = match
+ elif hint.endswith('_Integral'):
+ solvefunc = globals()['ode_' + hint[:-len('_Integral')]]
+ else:
+ solvefunc = globals()['ode_' + hint]
+
+ free = eq.free_symbols
+ cons = lambda s: s.free_symbols.difference(free)
+
+ if simplify:
+ # odesimp() will attempt to integrate, if necessary, apply constantsimp(),
+ # attempt to solve for func, and apply any other hint specific
+ # simplifications
+ if isinstance(solvefunc, SingleODESolver):
+ sols = solvefunc.get_general_solution()
+ else:
+ sols = solvefunc(eq, func, order, match)
+ if iterable(sols):
+ rv = [odesimp(eq, s, func, hint) for s in sols]
+ else:
+ rv = odesimp(eq, sols, func, hint)
+ else:
+ # We still want to integrate (you can disable it separately with the hint)
+ if isinstance(solvefunc, SingleODESolver):
+ exprs = solvefunc.get_general_solution(simplify=False)
+ else:
+ match['simplify'] = False # Some hints can take advantage of this option
+ exprs = solvefunc(eq, func, order, match)
+ if isinstance(exprs, list):
+ rv = [_handle_Integral(expr, func, hint) for expr in exprs]
+ else:
+ rv = _handle_Integral(exprs, func, hint)
+
+ if isinstance(rv, list):
+ if simplify:
+ rv = _remove_redundant_solutions(eq, rv, order, func.args[0])
+ if len(rv) == 1:
+ rv = rv[0]
+ if ics and 'power_series' not in hint:
+ if isinstance(rv, (Expr, Eq)):
+ solved_constants = solve_ics([rv], [r['func']], cons(rv), ics)
+ rv = rv.subs(solved_constants)
+ else:
+ rv1 = []
+ for s in rv:
+ try:
+ solved_constants = solve_ics([s], [r['func']], cons(s), ics)
+ except ValueError:
+ continue
+ rv1.append(s.subs(solved_constants))
+ if len(rv1) == 1:
+ return rv1[0]
+ rv = rv1
+ return rv
+
+def solve_ics(sols, funcs, constants, ics):
+ """
+ Solve for the constants given initial conditions
+
+ ``sols`` is a list of solutions.
+
+ ``funcs`` is a list of functions.
+
+ ``constants`` is a list of constants.
+
+ ``ics`` is the set of initial/boundary conditions for the differential
+ equation. It should be given in the form of ``{f(x0): x1,
+ f(x).diff(x).subs(x, x2): x3}`` and so on.
+
+ Returns a dictionary mapping constants to values.
+ ``solution.subs(constants)`` will replace the constants in ``solution``.
+
+ Example
+ =======
+ >>> # From dsolve(f(x).diff(x) - f(x), f(x))
+ >>> from sympy import symbols, Eq, exp, Function
+ >>> from sympy.solvers.ode.ode import solve_ics
+ >>> f = Function('f')
+ >>> x, C1 = symbols('x C1')
+ >>> sols = [Eq(f(x), C1*exp(x))]
+ >>> funcs = [f(x)]
+ >>> constants = [C1]
+ >>> ics = {f(0): 2}
+ >>> solved_constants = solve_ics(sols, funcs, constants, ics)
+ >>> solved_constants
+ {C1: 2}
+ >>> sols[0].subs(solved_constants)
+ Eq(f(x), 2*exp(x))
+
+ """
+ # Assume ics are of the form f(x0): value or Subs(diff(f(x), x, n), (x,
+ # x0)): value (currently checked by classify_ode). To solve, replace x
+ # with x0, f(x0) with value, then solve for constants. For f^(n)(x0),
+ # differentiate the solution n times, so that f^(n)(x) appears.
+ x = funcs[0].args[0]
+ diff_sols = []
+ subs_sols = []
+ diff_variables = set()
+ for funcarg, value in ics.items():
+ if isinstance(funcarg, AppliedUndef):
+ x0 = funcarg.args[0]
+ matching_func = [f for f in funcs if f.func == funcarg.func][0]
+ S = sols
+ elif isinstance(funcarg, (Subs, Derivative)):
+ if isinstance(funcarg, Subs):
+ # Make sure it stays a subs. Otherwise subs below will produce
+ # a different looking term.
+ funcarg = funcarg.doit()
+ if isinstance(funcarg, Subs):
+ deriv = funcarg.expr
+ x0 = funcarg.point[0]
+ variables = funcarg.expr.variables
+ matching_func = deriv
+ elif isinstance(funcarg, Derivative):
+ deriv = funcarg
+ x0 = funcarg.variables[0]
+ variables = (x,)*len(funcarg.variables)
+ matching_func = deriv.subs(x0, x)
+ for sol in sols:
+ if sol.has(deriv.expr.func):
+ diff_sols.append(Eq(sol.lhs.diff(*variables), sol.rhs.diff(*variables)))
+ diff_variables.add(variables)
+ S = diff_sols
+ else:
+ raise NotImplementedError("Unrecognized initial condition")
+
+ for sol in S:
+ if sol.has(matching_func):
+ sol2 = sol
+ sol2 = sol2.subs(x, x0)
+ sol2 = sol2.subs(funcarg, value)
+ # This check is necessary because of issue #15724
+ if not isinstance(sol2, BooleanAtom) or not subs_sols:
+ subs_sols = [s for s in subs_sols if not isinstance(s, BooleanAtom)]
+ subs_sols.append(sol2)
+
+ # TODO: Use solveset here
+ try:
+ solved_constants = solve(subs_sols, constants, dict=True)
+ except NotImplementedError:
+ solved_constants = []
+
+ # XXX: We can't differentiate between the solution not existing because of
+ # invalid initial conditions, and not existing because solve is not smart
+ # enough. If we could use solveset, this might be improvable, but for now,
+ # we use NotImplementedError in this case.
+ if not solved_constants:
+ raise ValueError("Couldn't solve for initial conditions")
+
+ if solved_constants == True:
+ raise ValueError("Initial conditions did not produce any solutions for constants. Perhaps they are degenerate.")
+
+ if len(solved_constants) > 1:
+ raise NotImplementedError("Initial conditions produced too many solutions for constants")
+
+ return solved_constants[0]
+
+def classify_ode(eq, func=None, dict=False, ics=None, *, prep=True, xi=None, eta=None, n=None, **kwargs):
+ r"""
+ Returns a tuple of possible :py:meth:`~sympy.solvers.ode.dsolve`
+ classifications for an ODE.
+
+ The tuple is ordered so that first item is the classification that
+ :py:meth:`~sympy.solvers.ode.dsolve` uses to solve the ODE by default. In
+ general, classifications at the near the beginning of the list will
+ produce better solutions faster than those near the end, thought there are
+ always exceptions. To make :py:meth:`~sympy.solvers.ode.dsolve` use a
+ different classification, use ``dsolve(ODE, func,
+ hint=)``. See also the
+ :py:meth:`~sympy.solvers.ode.dsolve` docstring for different meta-hints
+ you can use.
+
+ If ``dict`` is true, :py:meth:`~sympy.solvers.ode.classify_ode` will
+ return a dictionary of ``hint:match`` expression terms. This is intended
+ for internal use by :py:meth:`~sympy.solvers.ode.dsolve`. Note that
+ because dictionaries are ordered arbitrarily, this will most likely not be
+ in the same order as the tuple.
+
+ You can get help on different hints by executing
+ ``help(ode.ode_hintname)``, where ``hintname`` is the name of the hint
+ without ``_Integral``.
+
+ See :py:data:`~sympy.solvers.ode.allhints` or the
+ :py:mod:`~sympy.solvers.ode` docstring for a list of all supported hints
+ that can be returned from :py:meth:`~sympy.solvers.ode.classify_ode`.
+
+ Notes
+ =====
+
+ These are remarks on hint names.
+
+ ``_Integral``
+
+ If a classification has ``_Integral`` at the end, it will return the
+ expression with an unevaluated :py:class:`~.Integral`
+ class in it. Note that a hint may do this anyway if
+ :py:meth:`~sympy.core.expr.Expr.integrate` cannot do the integral,
+ though just using an ``_Integral`` will do so much faster. Indeed, an
+ ``_Integral`` hint will always be faster than its corresponding hint
+ without ``_Integral`` because
+ :py:meth:`~sympy.core.expr.Expr.integrate` is an expensive routine.
+ If :py:meth:`~sympy.solvers.ode.dsolve` hangs, it is probably because
+ :py:meth:`~sympy.core.expr.Expr.integrate` is hanging on a tough or
+ impossible integral. Try using an ``_Integral`` hint or
+ ``all_Integral`` to get it return something.
+
+ Note that some hints do not have ``_Integral`` counterparts. This is
+ because :py:func:`~sympy.integrals.integrals.integrate` is not used in
+ solving the ODE for those method. For example, `n`\th order linear
+ homogeneous ODEs with constant coefficients do not require integration
+ to solve, so there is no
+ ``nth_linear_homogeneous_constant_coeff_Integrate`` hint. You can
+ easily evaluate any unevaluated
+ :py:class:`~sympy.integrals.integrals.Integral`\s in an expression by
+ doing ``expr.doit()``.
+
+ Ordinals
+
+ Some hints contain an ordinal such as ``1st_linear``. This is to help
+ differentiate them from other hints, as well as from other methods
+ that may not be implemented yet. If a hint has ``nth`` in it, such as
+ the ``nth_linear`` hints, this means that the method used to applies
+ to ODEs of any order.
+
+ ``indep`` and ``dep``
+
+ Some hints contain the words ``indep`` or ``dep``. These reference
+ the independent variable and the dependent function, respectively. For
+ example, if an ODE is in terms of `f(x)`, then ``indep`` will refer to
+ `x` and ``dep`` will refer to `f`.
+
+ ``subs``
+
+ If a hints has the word ``subs`` in it, it means that the ODE is solved
+ by substituting the expression given after the word ``subs`` for a
+ single dummy variable. This is usually in terms of ``indep`` and
+ ``dep`` as above. The substituted expression will be written only in
+ characters allowed for names of Python objects, meaning operators will
+ be spelled out. For example, ``indep``/``dep`` will be written as
+ ``indep_div_dep``.
+
+ ``coeff``
+
+ The word ``coeff`` in a hint refers to the coefficients of something
+ in the ODE, usually of the derivative terms. See the docstring for
+ the individual methods for more info (``help(ode)``). This is
+ contrast to ``coefficients``, as in ``undetermined_coefficients``,
+ which refers to the common name of a method.
+
+ ``_best``
+
+ Methods that have more than one fundamental way to solve will have a
+ hint for each sub-method and a ``_best`` meta-classification. This
+ will evaluate all hints and return the best, using the same
+ considerations as the normal ``best`` meta-hint.
+
+
+ Examples
+ ========
+
+ >>> from sympy import Function, classify_ode, Eq
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> classify_ode(Eq(f(x).diff(x), 0), f(x))
+ ('nth_algebraic',
+ 'separable',
+ '1st_exact',
+ '1st_linear',
+ 'Bernoulli',
+ '1st_homogeneous_coeff_best',
+ '1st_homogeneous_coeff_subs_indep_div_dep',
+ '1st_homogeneous_coeff_subs_dep_div_indep',
+ '1st_power_series', 'lie_group', 'nth_linear_constant_coeff_homogeneous',
+ 'nth_linear_euler_eq_homogeneous',
+ 'nth_algebraic_Integral', 'separable_Integral', '1st_exact_Integral',
+ '1st_linear_Integral', 'Bernoulli_Integral',
+ '1st_homogeneous_coeff_subs_indep_div_dep_Integral',
+ '1st_homogeneous_coeff_subs_dep_div_indep_Integral')
+ >>> classify_ode(f(x).diff(x, 2) + 3*f(x).diff(x) + 2*f(x) - 4)
+ ('factorable', 'nth_linear_constant_coeff_undetermined_coefficients',
+ 'nth_linear_constant_coeff_variation_of_parameters',
+ 'nth_linear_constant_coeff_variation_of_parameters_Integral')
+
+ """
+ ics = sympify(ics)
+
+ if func and len(func.args) != 1:
+ raise ValueError("dsolve() and classify_ode() only "
+ "work with functions of one variable, not %s" % func)
+
+ if isinstance(eq, Equality):
+ eq = eq.lhs - eq.rhs
+
+ # Some methods want the unprocessed equation
+ eq_orig = eq
+
+ if prep or func is None:
+ eq, func_ = _preprocess(eq, func)
+ if func is None:
+ func = func_
+ x = func.args[0]
+ f = func.func
+ y = Dummy('y')
+ terms = 5 if n is None else n
+
+ order = ode_order(eq, f(x))
+ # hint:matchdict or hint:(tuple of matchdicts)
+ # Also will contain "default": and "order":order items.
+ matching_hints = {"order": order}
+
+ df = f(x).diff(x)
+ a = Wild('a', exclude=[f(x)])
+ d = Wild('d', exclude=[df, f(x).diff(x, 2)])
+ e = Wild('e', exclude=[df])
+ n = Wild('n', exclude=[x, f(x), df])
+ c1 = Wild('c1', exclude=[x])
+ a3 = Wild('a3', exclude=[f(x), df, f(x).diff(x, 2)])
+ b3 = Wild('b3', exclude=[f(x), df, f(x).diff(x, 2)])
+ c3 = Wild('c3', exclude=[f(x), df, f(x).diff(x, 2)])
+ boundary = {} # Used to extract initial conditions
+ C1 = Symbol("C1")
+
+ # Preprocessing to get the initial conditions out
+ if ics is not None:
+ for funcarg in ics:
+ # Separating derivatives
+ if isinstance(funcarg, (Subs, Derivative)):
+ # f(x).diff(x).subs(x, 0) is a Subs, but f(x).diff(x).subs(x,
+ # y) is a Derivative
+ if isinstance(funcarg, Subs):
+ deriv = funcarg.expr
+ old = funcarg.variables[0]
+ new = funcarg.point[0]
+ elif isinstance(funcarg, Derivative):
+ deriv = funcarg
+ # No information on this. Just assume it was x
+ old = x
+ new = funcarg.variables[0]
+
+ if (isinstance(deriv, Derivative) and isinstance(deriv.args[0],
+ AppliedUndef) and deriv.args[0].func == f and
+ len(deriv.args[0].args) == 1 and old == x and not
+ new.has(x) and all(i == deriv.variables[0] for i in
+ deriv.variables) and x not in ics[funcarg].free_symbols):
+
+ dorder = ode_order(deriv, x)
+ temp = 'f' + str(dorder)
+ boundary.update({temp: new, temp + 'val': ics[funcarg]})
+ else:
+ raise ValueError("Invalid boundary conditions for Derivatives")
+
+
+ # Separating functions
+ elif isinstance(funcarg, AppliedUndef):
+ if (funcarg.func == f and len(funcarg.args) == 1 and
+ not funcarg.args[0].has(x) and x not in ics[funcarg].free_symbols):
+ boundary.update({'f0': funcarg.args[0], 'f0val': ics[funcarg]})
+ else:
+ raise ValueError("Invalid boundary conditions for Function")
+
+ else:
+ raise ValueError("Enter boundary conditions of the form ics={f(point): value, f(x).diff(x, order).subs(x, point): value}")
+
+ ode = SingleODEProblem(eq_orig, func, x, prep=prep, xi=xi, eta=eta)
+ user_hint = kwargs.get('hint', 'default')
+ # Used when dsolve is called without an explicit hint.
+ # We exit early to return the first valid match
+ early_exit = (user_hint=='default')
+ if user_hint.endswith('_Integral'):
+ user_hint = user_hint[:-len('_Integral')]
+ user_map = solver_map
+ # An explicit hint has been given to dsolve
+ # Skip matching code for other hints
+ if user_hint not in ['default', 'all', 'all_Integral', 'best'] and user_hint in solver_map:
+ user_map = {user_hint: solver_map[user_hint]}
+
+ for hint in user_map:
+ solver = user_map[hint](ode)
+ if solver.matches():
+ matching_hints[hint] = solver
+ if user_map[hint].has_integral:
+ matching_hints[hint + "_Integral"] = solver
+ if dict and early_exit:
+ matching_hints["default"] = hint
+ return matching_hints
+
+ eq = expand(eq)
+ # Precondition to try remove f(x) from highest order derivative
+ reduced_eq = None
+ if eq.is_Add:
+ deriv_coef = eq.coeff(f(x).diff(x, order))
+ if deriv_coef not in (1, 0):
+ r = deriv_coef.match(a*f(x)**c1)
+ if r and r[c1]:
+ den = f(x)**r[c1]
+ reduced_eq = Add(*[arg/den for arg in eq.args])
+ if not reduced_eq:
+ reduced_eq = eq
+
+ if order == 1:
+
+ # NON-REDUCED FORM OF EQUATION matches
+ r = collect(eq, df, exact=True).match(d + e * df)
+ if r:
+ r['d'] = d
+ r['e'] = e
+ r['y'] = y
+ r[d] = r[d].subs(f(x), y)
+ r[e] = r[e].subs(f(x), y)
+
+ # FIRST ORDER POWER SERIES WHICH NEEDS INITIAL CONDITIONS
+ # TODO: Hint first order series should match only if d/e is analytic.
+ # For now, only d/e and (d/e).diff(arg) is checked for existence at
+ # at a given point.
+ # This is currently done internally in ode_1st_power_series.
+ point = boundary.get('f0', 0)
+ value = boundary.get('f0val', C1)
+ check = cancel(r[d]/r[e])
+ check1 = check.subs({x: point, y: value})
+ if not check1.has(oo) and not check1.has(zoo) and \
+ not check1.has(nan) and not check1.has(-oo):
+ check2 = (check1.diff(x)).subs({x: point, y: value})
+ if not check2.has(oo) and not check2.has(zoo) and \
+ not check2.has(nan) and not check2.has(-oo):
+ rseries = r.copy()
+ rseries.update({'terms': terms, 'f0': point, 'f0val': value})
+ matching_hints["1st_power_series"] = rseries
+
+ elif order == 2:
+ # Homogeneous second order differential equation of the form
+ # a3*f(x).diff(x, 2) + b3*f(x).diff(x) + c3
+ # It has a definite power series solution at point x0 if, b3/a3 and c3/a3
+ # are analytic at x0.
+ deq = a3*(f(x).diff(x, 2)) + b3*df + c3*f(x)
+ r = collect(reduced_eq,
+ [f(x).diff(x, 2), f(x).diff(x), f(x)]).match(deq)
+ ordinary = False
+ if r:
+ if not all(r[key].is_polynomial() for key in r):
+ n, d = reduced_eq.as_numer_denom()
+ reduced_eq = expand(n)
+ r = collect(reduced_eq,
+ [f(x).diff(x, 2), f(x).diff(x), f(x)]).match(deq)
+ if r and r[a3] != 0:
+ p = cancel(r[b3]/r[a3]) # Used below
+ q = cancel(r[c3]/r[a3]) # Used below
+ point = kwargs.get('x0', 0)
+ check = p.subs(x, point)
+ if not check.has(oo, nan, zoo, -oo):
+ check = q.subs(x, point)
+ if not check.has(oo, nan, zoo, -oo):
+ ordinary = True
+ r.update({'a3': a3, 'b3': b3, 'c3': c3, 'x0': point, 'terms': terms})
+ matching_hints["2nd_power_series_ordinary"] = r
+
+ # Checking if the differential equation has a regular singular point
+ # at x0. It has a regular singular point at x0, if (b3/a3)*(x - x0)
+ # and (c3/a3)*((x - x0)**2) are analytic at x0.
+ if not ordinary:
+ p = cancel((x - point)*p)
+ check = p.subs(x, point)
+ if not check.has(oo, nan, zoo, -oo):
+ q = cancel(((x - point)**2)*q)
+ check = q.subs(x, point)
+ if not check.has(oo, nan, zoo, -oo):
+ coeff_dict = {'p': p, 'q': q, 'x0': point, 'terms': terms}
+ matching_hints["2nd_power_series_regular"] = coeff_dict
+
+
+ # Order keys based on allhints.
+ retlist = [i for i in allhints if i in matching_hints]
+ if dict:
+ # Dictionaries are ordered arbitrarily, so make note of which
+ # hint would come first for dsolve(). Use an ordered dict in Py 3.
+ matching_hints["default"] = retlist[0] if retlist else None
+ matching_hints["ordered_hints"] = tuple(retlist)
+ return matching_hints
+ else:
+ return tuple(retlist)
+
+
+def classify_sysode(eq, funcs=None, **kwargs):
+ r"""
+ Returns a dictionary of parameter names and values that define the system
+ of ordinary differential equations in ``eq``.
+ The parameters are further used in
+ :py:meth:`~sympy.solvers.ode.dsolve` for solving that system.
+
+ Some parameter names and values are:
+
+ 'is_linear' (boolean), which tells whether the given system is linear.
+ Note that "linear" here refers to the operator: terms such as ``x*diff(x,t)`` are
+ nonlinear, whereas terms like ``sin(t)*diff(x,t)`` are still linear operators.
+
+ 'func' (list) contains the :py:class:`~sympy.core.function.Function`s that
+ appear with a derivative in the ODE, i.e. those that we are trying to solve
+ the ODE for.
+
+ 'order' (dict) with the maximum derivative for each element of the 'func'
+ parameter.
+
+ 'func_coeff' (dict or Matrix) with the coefficient for each triple ``(equation number,
+ function, order)```. The coefficients are those subexpressions that do not
+ appear in 'func', and hence can be considered constant for purposes of ODE
+ solving. The value of this parameter can also be a Matrix if the system of ODEs are
+ linear first order of the form X' = AX where X is the vector of dependent variables.
+ Here, this function returns the coefficient matrix A.
+
+ 'eq' (list) with the equations from ``eq``, sympified and transformed into
+ expressions (we are solving for these expressions to be zero).
+
+ 'no_of_equations' (int) is the number of equations (same as ``len(eq)``).
+
+ 'type_of_equation' (string) is an internal classification of the type of
+ ODE.
+
+ 'is_constant' (boolean), which tells if the system of ODEs is constant coefficient
+ or not. This key is temporary addition for now and is in the match dict only when
+ the system of ODEs is linear first order constant coefficient homogeneous. So, this
+ key's value is True for now if it is available else it does not exist.
+
+ 'is_homogeneous' (boolean), which tells if the system of ODEs is homogeneous. Like the
+ key 'is_constant', this key is a temporary addition and it is True since this key value
+ is available only when the system is linear first order constant coefficient homogeneous.
+
+ References
+ ==========
+ -https://eqworld.ipmnet.ru/en/solutions/sysode/sode-toc1.htm
+ -A. D. Polyanin and A. V. Manzhirov, Handbook of Mathematics for Engineers and Scientists
+
+ Examples
+ ========
+
+ >>> from sympy import Function, Eq, symbols, diff
+ >>> from sympy.solvers.ode.ode import classify_sysode
+ >>> from sympy.abc import t
+ >>> f, x, y = symbols('f, x, y', cls=Function)
+ >>> k, l, m, n = symbols('k, l, m, n', Integer=True)
+ >>> x1 = diff(x(t), t) ; y1 = diff(y(t), t)
+ >>> x2 = diff(x(t), t, t) ; y2 = diff(y(t), t, t)
+ >>> eq = (Eq(x1, 12*x(t) - 6*y(t)), Eq(y1, 11*x(t) + 3*y(t)))
+ >>> classify_sysode(eq)
+ {'eq': [-12*x(t) + 6*y(t) + Derivative(x(t), t), -11*x(t) - 3*y(t) + Derivative(y(t), t)], 'func': [x(t), y(t)],
+ 'func_coeff': {(0, x(t), 0): -12, (0, x(t), 1): 1, (0, y(t), 0): 6, (0, y(t), 1): 0, (1, x(t), 0): -11, (1, x(t), 1): 0, (1, y(t), 0): -3, (1, y(t), 1): 1}, 'is_linear': True, 'no_of_equation': 2, 'order': {x(t): 1, y(t): 1}, 'type_of_equation': None}
+ >>> eq = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t) + 2), Eq(diff(y(t),t), -t**2*x(t) + 5*t*y(t)))
+ >>> classify_sysode(eq)
+ {'eq': [-t**2*y(t) - 5*t*x(t) + Derivative(x(t), t) - 2, t**2*x(t) - 5*t*y(t) + Derivative(y(t), t)],
+ 'func': [x(t), y(t)], 'func_coeff': {(0, x(t), 0): -5*t, (0, x(t), 1): 1, (0, y(t), 0): -t**2, (0, y(t), 1): 0,
+ (1, x(t), 0): t**2, (1, x(t), 1): 0, (1, y(t), 0): -5*t, (1, y(t), 1): 1}, 'is_linear': True, 'no_of_equation': 2,
+ 'order': {x(t): 1, y(t): 1}, 'type_of_equation': None}
+
+ """
+
+ # Sympify equations and convert iterables of equations into
+ # a list of equations
+ def _sympify(eq):
+ return list(map(sympify, eq if iterable(eq) else [eq]))
+
+ eq, funcs = (_sympify(w) for w in [eq, funcs])
+ for i, fi in enumerate(eq):
+ if isinstance(fi, Equality):
+ eq[i] = fi.lhs - fi.rhs
+
+ t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+ matching_hints = {"no_of_equation":i+1}
+ matching_hints['eq'] = eq
+ if i==0:
+ raise ValueError("classify_sysode() works for systems of ODEs. "
+ "For scalar ODEs, classify_ode should be used")
+
+ # find all the functions if not given
+ order = {}
+ if funcs==[None]:
+ funcs = _extract_funcs(eq)
+
+ funcs = list(set(funcs))
+ if len(funcs) != len(eq):
+ raise ValueError("Number of functions given is not equal to the number of equations %s" % funcs)
+
+ # This logic of list of lists in funcs to
+ # be replaced later.
+ func_dict = {}
+ for func in funcs:
+ if not order.get(func, False):
+ max_order = 0
+ for i, eqs_ in enumerate(eq):
+ order_ = ode_order(eqs_,func)
+ if max_order < order_:
+ max_order = order_
+ eq_no = i
+ if eq_no in func_dict:
+ func_dict[eq_no] = [func_dict[eq_no], func]
+ else:
+ func_dict[eq_no] = func
+ order[func] = max_order
+
+ funcs = [func_dict[i] for i in range(len(func_dict))]
+ matching_hints['func'] = funcs
+ for func in funcs:
+ if isinstance(func, list):
+ for func_elem in func:
+ if len(func_elem.args) != 1:
+ raise ValueError("dsolve() and classify_sysode() work with "
+ "functions of one variable only, not %s" % func)
+ else:
+ if func and len(func.args) != 1:
+ raise ValueError("dsolve() and classify_sysode() work with "
+ "functions of one variable only, not %s" % func)
+
+ # find the order of all equation in system of odes
+ matching_hints["order"] = order
+
+ # find coefficients of terms f(t), diff(f(t),t) and higher derivatives
+ # and similarly for other functions g(t), diff(g(t),t) in all equations.
+ # Here j denotes the equation number, funcs[l] denotes the function about
+ # which we are talking about and k denotes the order of function funcs[l]
+ # whose coefficient we are calculating.
+ def linearity_check(eqs, j, func, is_linear_):
+ for k in range(order[func] + 1):
+ func_coef[j, func, k] = collect(eqs.expand(), [diff(func, t, k)]).coeff(diff(func, t, k))
+ if is_linear_ == True:
+ if func_coef[j, func, k] == 0:
+ if k == 0:
+ coef = eqs.as_independent(func, as_Add=True)[1]
+ for xr in range(1, ode_order(eqs,func) + 1):
+ coef -= eqs.as_independent(diff(func, t, xr), as_Add=True)[1]
+ if coef != 0:
+ is_linear_ = False
+ else:
+ if eqs.as_independent(diff(func, t, k), as_Add=True)[1]:
+ is_linear_ = False
+ else:
+ for func_ in funcs:
+ if isinstance(func_, list):
+ for elem_func_ in func_:
+ dep = func_coef[j, func, k].as_independent(elem_func_, as_Add=True)[1]
+ if dep != 0:
+ is_linear_ = False
+ else:
+ dep = func_coef[j, func, k].as_independent(func_, as_Add=True)[1]
+ if dep != 0:
+ is_linear_ = False
+ return is_linear_
+
+ func_coef = {}
+ is_linear = True
+ for j, eqs in enumerate(eq):
+ for func in funcs:
+ if isinstance(func, list):
+ for func_elem in func:
+ is_linear = linearity_check(eqs, j, func_elem, is_linear)
+ else:
+ is_linear = linearity_check(eqs, j, func, is_linear)
+ matching_hints['func_coeff'] = func_coef
+ matching_hints['is_linear'] = is_linear
+
+
+ if len(set(order.values())) == 1:
+ order_eq = list(matching_hints['order'].values())[0]
+ if matching_hints['is_linear'] == True:
+ if matching_hints['no_of_equation'] == 2:
+ if order_eq == 1:
+ type_of_equation = check_linear_2eq_order1(eq, funcs, func_coef)
+ else:
+ type_of_equation = None
+ # If the equation does not match up with any of the
+ # general case solvers in systems.py and the number
+ # of equations is greater than 2, then NotImplementedError
+ # should be raised.
+ else:
+ type_of_equation = None
+
+ else:
+ if matching_hints['no_of_equation'] == 2:
+ if order_eq == 1:
+ type_of_equation = check_nonlinear_2eq_order1(eq, funcs, func_coef)
+ else:
+ type_of_equation = None
+ elif matching_hints['no_of_equation'] == 3:
+ if order_eq == 1:
+ type_of_equation = check_nonlinear_3eq_order1(eq, funcs, func_coef)
+ else:
+ type_of_equation = None
+ else:
+ type_of_equation = None
+ else:
+ type_of_equation = None
+
+ matching_hints['type_of_equation'] = type_of_equation
+
+ return matching_hints
+
+
+def check_linear_2eq_order1(eq, func, func_coef):
+ x = func[0].func
+ y = func[1].func
+ fc = func_coef
+ t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+ r = {}
+ # for equations Eq(a1*diff(x(t),t), b1*x(t) + c1*y(t) + d1)
+ # and Eq(a2*diff(y(t),t), b2*x(t) + c2*y(t) + d2)
+ r['a1'] = fc[0,x(t),1] ; r['a2'] = fc[1,y(t),1]
+ r['b1'] = -fc[0,x(t),0]/fc[0,x(t),1] ; r['b2'] = -fc[1,x(t),0]/fc[1,y(t),1]
+ r['c1'] = -fc[0,y(t),0]/fc[0,x(t),1] ; r['c2'] = -fc[1,y(t),0]/fc[1,y(t),1]
+ forcing = [S.Zero,S.Zero]
+ for i in range(2):
+ for j in Add.make_args(eq[i]):
+ if not j.has(x(t), y(t)):
+ forcing[i] += j
+ if not (forcing[0].has(t) or forcing[1].has(t)):
+ # We can handle homogeneous case and simple constant forcings
+ r['d1'] = forcing[0]
+ r['d2'] = forcing[1]
+ else:
+ # Issue #9244: nonhomogeneous linear systems are not supported
+ return None
+
+ # Conditions to check for type 6 whose equations are Eq(diff(x(t),t), f(t)*x(t) + g(t)*y(t)) and
+ # Eq(diff(y(t),t), a*[f(t) + a*h(t)]x(t) + a*[g(t) - h(t)]*y(t))
+ p = 0
+ q = 0
+ p1 = cancel(r['b2']/(cancel(r['b2']/r['c2']).as_numer_denom()[0]))
+ p2 = cancel(r['b1']/(cancel(r['b1']/r['c1']).as_numer_denom()[0]))
+ for n, i in enumerate([p1, p2]):
+ for j in Mul.make_args(collect_const(i)):
+ if not j.has(t):
+ q = j
+ if q and n==0:
+ if ((r['b2']/j - r['b1'])/(r['c1'] - r['c2']/j)) == j:
+ p = 1
+ elif q and n==1:
+ if ((r['b1']/j - r['b2'])/(r['c2'] - r['c1']/j)) == j:
+ p = 2
+ # End of condition for type 6
+
+ if r['d1']!=0 or r['d2']!=0:
+ return None
+ else:
+ if not any(r[k].has(t) for k in 'a1 a2 b1 b2 c1 c2'.split()):
+ return None
+ else:
+ r['b1'] = r['b1']/r['a1'] ; r['b2'] = r['b2']/r['a2']
+ r['c1'] = r['c1']/r['a1'] ; r['c2'] = r['c2']/r['a2']
+ if p:
+ return "type6"
+ else:
+ # Equations for type 7 are Eq(diff(x(t),t), f(t)*x(t) + g(t)*y(t)) and Eq(diff(y(t),t), h(t)*x(t) + p(t)*y(t))
+ return "type7"
+def check_nonlinear_2eq_order1(eq, func, func_coef):
+ t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+ f = Wild('f')
+ g = Wild('g')
+ u, v = symbols('u, v', cls=Dummy)
+ def check_type(x, y):
+ r1 = eq[0].match(t*diff(x(t),t) - x(t) + f)
+ r2 = eq[1].match(t*diff(y(t),t) - y(t) + g)
+ if not (r1 and r2):
+ r1 = eq[0].match(diff(x(t),t) - x(t)/t + f/t)
+ r2 = eq[1].match(diff(y(t),t) - y(t)/t + g/t)
+ if not (r1 and r2):
+ r1 = (-eq[0]).match(t*diff(x(t),t) - x(t) + f)
+ r2 = (-eq[1]).match(t*diff(y(t),t) - y(t) + g)
+ if not (r1 and r2):
+ r1 = (-eq[0]).match(diff(x(t),t) - x(t)/t + f/t)
+ r2 = (-eq[1]).match(diff(y(t),t) - y(t)/t + g/t)
+ if r1 and r2 and not (r1[f].subs(diff(x(t),t),u).subs(diff(y(t),t),v).has(t) \
+ or r2[g].subs(diff(x(t),t),u).subs(diff(y(t),t),v).has(t)):
+ return 'type5'
+ else:
+ return None
+ for func_ in func:
+ if isinstance(func_, list):
+ x = func[0][0].func
+ y = func[0][1].func
+ eq_type = check_type(x, y)
+ if not eq_type:
+ eq_type = check_type(y, x)
+ return eq_type
+ x = func[0].func
+ y = func[1].func
+ fc = func_coef
+ n = Wild('n', exclude=[x(t),y(t)])
+ f1 = Wild('f1', exclude=[v,t])
+ f2 = Wild('f2', exclude=[v,t])
+ g1 = Wild('g1', exclude=[u,t])
+ g2 = Wild('g2', exclude=[u,t])
+ for i in range(2):
+ eqs = 0
+ for terms in Add.make_args(eq[i]):
+ eqs += terms/fc[i,func[i],1]
+ eq[i] = eqs
+ r = eq[0].match(diff(x(t),t) - x(t)**n*f)
+ if r:
+ g = (diff(y(t),t) - eq[1])/r[f]
+ if r and not (g.has(x(t)) or g.subs(y(t),v).has(t) or r[f].subs(x(t),u).subs(y(t),v).has(t)):
+ return 'type1'
+ r = eq[0].match(diff(x(t),t) - exp(n*x(t))*f)
+ if r:
+ g = (diff(y(t),t) - eq[1])/r[f]
+ if r and not (g.has(x(t)) or g.subs(y(t),v).has(t) or r[f].subs(x(t),u).subs(y(t),v).has(t)):
+ return 'type2'
+ g = Wild('g')
+ r1 = eq[0].match(diff(x(t),t) - f)
+ r2 = eq[1].match(diff(y(t),t) - g)
+ if r1 and r2 and not (r1[f].subs(x(t),u).subs(y(t),v).has(t) or \
+ r2[g].subs(x(t),u).subs(y(t),v).has(t)):
+ return 'type3'
+ r1 = eq[0].match(diff(x(t),t) - f)
+ r2 = eq[1].match(diff(y(t),t) - g)
+ num, den = (
+ (r1[f].subs(x(t),u).subs(y(t),v))/
+ (r2[g].subs(x(t),u).subs(y(t),v))).as_numer_denom()
+ R1 = num.match(f1*g1)
+ R2 = den.match(f2*g2)
+ # phi = (r1[f].subs(x(t),u).subs(y(t),v))/num
+ if R1 and R2:
+ return 'type4'
+ return None
+
+
+def check_nonlinear_2eq_order2(eq, func, func_coef):
+ return None
+
+def check_nonlinear_3eq_order1(eq, func, func_coef):
+ x = func[0].func
+ y = func[1].func
+ z = func[2].func
+ fc = func_coef
+ t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+ u, v, w = symbols('u, v, w', cls=Dummy)
+ a = Wild('a', exclude=[x(t), y(t), z(t), t])
+ b = Wild('b', exclude=[x(t), y(t), z(t), t])
+ c = Wild('c', exclude=[x(t), y(t), z(t), t])
+ f = Wild('f')
+ F1 = Wild('F1')
+ F2 = Wild('F2')
+ F3 = Wild('F3')
+ for i in range(3):
+ eqs = 0
+ for terms in Add.make_args(eq[i]):
+ eqs += terms/fc[i,func[i],1]
+ eq[i] = eqs
+ r1 = eq[0].match(diff(x(t),t) - a*y(t)*z(t))
+ r2 = eq[1].match(diff(y(t),t) - b*z(t)*x(t))
+ r3 = eq[2].match(diff(z(t),t) - c*x(t)*y(t))
+ if r1 and r2 and r3:
+ num1, den1 = r1[a].as_numer_denom()
+ num2, den2 = r2[b].as_numer_denom()
+ num3, den3 = r3[c].as_numer_denom()
+ if solve([num1*u-den1*(v-w), num2*v-den2*(w-u), num3*w-den3*(u-v)],[u, v]):
+ return 'type1'
+ r = eq[0].match(diff(x(t),t) - y(t)*z(t)*f)
+ if r:
+ r1 = collect_const(r[f]).match(a*f)
+ r2 = ((diff(y(t),t) - eq[1])/r1[f]).match(b*z(t)*x(t))
+ r3 = ((diff(z(t),t) - eq[2])/r1[f]).match(c*x(t)*y(t))
+ if r1 and r2 and r3:
+ num1, den1 = r1[a].as_numer_denom()
+ num2, den2 = r2[b].as_numer_denom()
+ num3, den3 = r3[c].as_numer_denom()
+ if solve([num1*u-den1*(v-w), num2*v-den2*(w-u), num3*w-den3*(u-v)],[u, v]):
+ return 'type2'
+ r = eq[0].match(diff(x(t),t) - (F2-F3))
+ if r:
+ r1 = collect_const(r[F2]).match(c*F2)
+ r1.update(collect_const(r[F3]).match(b*F3))
+ if r1:
+ if eq[1].has(r1[F2]) and not eq[1].has(r1[F3]):
+ r1[F2], r1[F3] = r1[F3], r1[F2]
+ r1[c], r1[b] = -r1[b], -r1[c]
+ r2 = eq[1].match(diff(y(t),t) - a*r1[F3] + r1[c]*F1)
+ if r2:
+ r3 = (eq[2] == diff(z(t),t) - r1[b]*r2[F1] + r2[a]*r1[F2])
+ if r1 and r2 and r3:
+ return 'type3'
+ r = eq[0].match(diff(x(t),t) - z(t)*F2 + y(t)*F3)
+ if r:
+ r1 = collect_const(r[F2]).match(c*F2)
+ r1.update(collect_const(r[F3]).match(b*F3))
+ if r1:
+ if eq[1].has(r1[F2]) and not eq[1].has(r1[F3]):
+ r1[F2], r1[F3] = r1[F3], r1[F2]
+ r1[c], r1[b] = -r1[b], -r1[c]
+ r2 = (diff(y(t),t) - eq[1]).match(a*x(t)*r1[F3] - r1[c]*z(t)*F1)
+ if r2:
+ r3 = (diff(z(t),t) - eq[2] == r1[b]*y(t)*r2[F1] - r2[a]*x(t)*r1[F2])
+ if r1 and r2 and r3:
+ return 'type4'
+ r = (diff(x(t),t) - eq[0]).match(x(t)*(F2 - F3))
+ if r:
+ r1 = collect_const(r[F2]).match(c*F2)
+ r1.update(collect_const(r[F3]).match(b*F3))
+ if r1:
+ if eq[1].has(r1[F2]) and not eq[1].has(r1[F3]):
+ r1[F2], r1[F3] = r1[F3], r1[F2]
+ r1[c], r1[b] = -r1[b], -r1[c]
+ r2 = (diff(y(t),t) - eq[1]).match(y(t)*(a*r1[F3] - r1[c]*F1))
+ if r2:
+ r3 = (diff(z(t),t) - eq[2] == z(t)*(r1[b]*r2[F1] - r2[a]*r1[F2]))
+ if r1 and r2 and r3:
+ return 'type5'
+ return None
+
+
+def check_nonlinear_3eq_order2(eq, func, func_coef):
+ return None
+
+
+@vectorize(0)
+def odesimp(ode, eq, func, hint):
+ r"""
+ Simplifies solutions of ODEs, including trying to solve for ``func`` and
+ running :py:meth:`~sympy.solvers.ode.constantsimp`.
+
+ It may use knowledge of the type of solution that the hint returns to
+ apply additional simplifications.
+
+ It also attempts to integrate any :py:class:`~sympy.integrals.integrals.Integral`\s
+ in the expression, if the hint is not an ``_Integral`` hint.
+
+ This function should have no effect on expressions returned by
+ :py:meth:`~sympy.solvers.ode.dsolve`, as
+ :py:meth:`~sympy.solvers.ode.dsolve` already calls
+ :py:meth:`~sympy.solvers.ode.ode.odesimp`, but the individual hint functions
+ do not call :py:meth:`~sympy.solvers.ode.ode.odesimp` (because the
+ :py:meth:`~sympy.solvers.ode.dsolve` wrapper does). Therefore, this
+ function is designed for mainly internal use.
+
+ Examples
+ ========
+
+ >>> from sympy import sin, symbols, dsolve, pprint, Function
+ >>> from sympy.solvers.ode.ode import odesimp
+ >>> x, u2, C1= symbols('x,u2,C1')
+ >>> f = Function('f')
+
+ >>> eq = dsolve(x*f(x).diff(x) - f(x) - x*sin(f(x)/x), f(x),
+ ... hint='1st_homogeneous_coeff_subs_indep_div_dep_Integral',
+ ... simplify=False)
+ >>> pprint(eq, wrap_line=False)
+ x
+ ----
+ f(x)
+ /
+ |
+ | / 1 \
+ | -|u1 + -------|
+ | | /1 \|
+ | | sin|--||
+ | \ \u1//
+ log(f(x)) = log(C1) + | ---------------- d(u1)
+ | 2
+ | u1
+ |
+ /
+
+ >>> pprint(odesimp(eq, f(x), 1, {C1},
+ ... hint='1st_homogeneous_coeff_subs_indep_div_dep'
+ ... )) #doctest: +SKIP
+ x
+ --------- = C1
+ /f(x)\
+ tan|----|
+ \2*x /
+
+ """
+ x = func.args[0]
+ f = func.func
+ C1 = get_numbered_constants(eq, num=1)
+ constants = eq.free_symbols - ode.free_symbols
+
+ # First, integrate if the hint allows it.
+ eq = _handle_Integral(eq, func, hint)
+ if hint.startswith("nth_linear_euler_eq_nonhomogeneous"):
+ eq = simplify(eq)
+ if not isinstance(eq, Equality):
+ raise TypeError("eq should be an instance of Equality")
+
+ # Second, clean up the arbitrary constants.
+ # Right now, nth linear hints can put as many as 2*order constants in an
+ # expression. If that number grows with another hint, the third argument
+ # here should be raised accordingly, or constantsimp() rewritten to handle
+ # an arbitrary number of constants.
+ eq = constantsimp(eq, constants)
+
+ # Lastly, now that we have cleaned up the expression, try solving for func.
+ # When CRootOf is implemented in solve(), we will want to return a CRootOf
+ # every time instead of an Equality.
+
+ # Get the f(x) on the left if possible.
+ if eq.rhs == func and not eq.lhs.has(func):
+ eq = [Eq(eq.rhs, eq.lhs)]
+
+ # make sure we are working with lists of solutions in simplified form.
+ if eq.lhs == func and not eq.rhs.has(func):
+ # The solution is already solved
+ eq = [eq]
+
+ else:
+ # The solution is not solved, so try to solve it
+ try:
+ floats = any(i.is_Float for i in eq.atoms(Number))
+ eqsol = solve(eq, func, force=True, rational=False if floats else None)
+ if not eqsol:
+ raise NotImplementedError
+ except (NotImplementedError, PolynomialError):
+ eq = [eq]
+ else:
+ def _expand(expr):
+ numer, denom = expr.as_numer_denom()
+
+ if denom.is_Add:
+ return expr
+ else:
+ return powsimp(expr.expand(), combine='exp', deep=True)
+
+ # XXX: the rest of odesimp() expects each ``t`` to be in a
+ # specific normal form: rational expression with numerator
+ # expanded, but with combined exponential functions (at
+ # least in this setup all tests pass).
+ eq = [Eq(f(x), _expand(t)) for t in eqsol]
+
+ # special simplification of the lhs.
+ if hint.startswith("1st_homogeneous_coeff"):
+ for j, eqi in enumerate(eq):
+ newi = logcombine(eqi, force=True)
+ if isinstance(newi.lhs, log) and newi.rhs == 0:
+ newi = Eq(newi.lhs.args[0]/C1, C1)
+ eq[j] = newi
+
+ # We cleaned up the constants before solving to help the solve engine with
+ # a simpler expression, but the solved expression could have introduced
+ # things like -C1, so rerun constantsimp() one last time before returning.
+ for i, eqi in enumerate(eq):
+ eq[i] = constantsimp(eqi, constants)
+ eq[i] = constant_renumber(eq[i], ode.free_symbols)
+
+ # If there is only 1 solution, return it;
+ # otherwise return the list of solutions.
+ if len(eq) == 1:
+ eq = eq[0]
+ return eq
+
+
+def ode_sol_simplicity(sol, func, trysolving=True):
+ r"""
+ Returns an extended integer representing how simple a solution to an ODE
+ is.
+
+ The following things are considered, in order from most simple to least:
+
+ - ``sol`` is solved for ``func``.
+ - ``sol`` is not solved for ``func``, but can be if passed to solve (e.g.,
+ a solution returned by ``dsolve(ode, func, simplify=False``).
+ - If ``sol`` is not solved for ``func``, then base the result on the
+ length of ``sol``, as computed by ``len(str(sol))``.
+ - If ``sol`` has any unevaluated :py:class:`~sympy.integrals.integrals.Integral`\s,
+ this will automatically be considered less simple than any of the above.
+
+ This function returns an integer such that if solution A is simpler than
+ solution B by above metric, then ``ode_sol_simplicity(sola, func) <
+ ode_sol_simplicity(solb, func)``.
+
+ Currently, the following are the numbers returned, but if the heuristic is
+ ever improved, this may change. Only the ordering is guaranteed.
+
+ +----------------------------------------------+-------------------+
+ | Simplicity | Return |
+ +==============================================+===================+
+ | ``sol`` solved for ``func`` | ``-2`` |
+ +----------------------------------------------+-------------------+
+ | ``sol`` not solved for ``func`` but can be | ``-1`` |
+ +----------------------------------------------+-------------------+
+ | ``sol`` is not solved nor solvable for | ``len(str(sol))`` |
+ | ``func`` | |
+ +----------------------------------------------+-------------------+
+ | ``sol`` contains an | ``oo`` |
+ | :obj:`~sympy.integrals.integrals.Integral` | |
+ +----------------------------------------------+-------------------+
+
+ ``oo`` here means the SymPy infinity, which should compare greater than
+ any integer.
+
+ If you already know :py:meth:`~sympy.solvers.solvers.solve` cannot solve
+ ``sol``, you can use ``trysolving=False`` to skip that step, which is the
+ only potentially slow step. For example,
+ :py:meth:`~sympy.solvers.ode.dsolve` with the ``simplify=False`` flag
+ should do this.
+
+ If ``sol`` is a list of solutions, if the worst solution in the list
+ returns ``oo`` it returns that, otherwise it returns ``len(str(sol))``,
+ that is, the length of the string representation of the whole list.
+
+ Examples
+ ========
+
+ This function is designed to be passed to ``min`` as the key argument,
+ such as ``min(listofsolutions, key=lambda i: ode_sol_simplicity(i,
+ f(x)))``.
+
+ >>> from sympy import symbols, Function, Eq, tan, Integral
+ >>> from sympy.solvers.ode.ode import ode_sol_simplicity
+ >>> x, C1, C2 = symbols('x, C1, C2')
+ >>> f = Function('f')
+
+ >>> ode_sol_simplicity(Eq(f(x), C1*x**2), f(x))
+ -2
+ >>> ode_sol_simplicity(Eq(x**2 + f(x), C1), f(x))
+ -1
+ >>> ode_sol_simplicity(Eq(f(x), C1*Integral(2*x, x)), f(x))
+ oo
+ >>> eq1 = Eq(f(x)/tan(f(x)/(2*x)), C1)
+ >>> eq2 = Eq(f(x)/tan(f(x)/(2*x) + f(x)), C2)
+ >>> [ode_sol_simplicity(eq, f(x)) for eq in [eq1, eq2]]
+ [28, 35]
+ >>> min([eq1, eq2], key=lambda i: ode_sol_simplicity(i, f(x)))
+ Eq(f(x)/tan(f(x)/(2*x)), C1)
+
+ """
+ # TODO: if two solutions are solved for f(x), we still want to be
+ # able to get the simpler of the two
+
+ # See the docstring for the coercion rules. We check easier (faster)
+ # things here first, to save time.
+
+ if iterable(sol):
+ # See if there are Integrals
+ for i in sol:
+ if ode_sol_simplicity(i, func, trysolving=trysolving) == oo:
+ return oo
+
+ return len(str(sol))
+
+ if sol.has(Integral):
+ return oo
+
+ # Next, try to solve for func. This code will change slightly when CRootOf
+ # is implemented in solve(). Probably a CRootOf solution should fall
+ # somewhere between a normal solution and an unsolvable expression.
+
+ # First, see if they are already solved
+ if sol.lhs == func and not sol.rhs.has(func) or \
+ sol.rhs == func and not sol.lhs.has(func):
+ return -2
+ # We are not so lucky, try solving manually
+ if trysolving:
+ try:
+ sols = solve(sol, func)
+ if not sols:
+ raise NotImplementedError
+ except NotImplementedError:
+ pass
+ else:
+ return -1
+
+ # Finally, a naive computation based on the length of the string version
+ # of the expression. This may favor combined fractions because they
+ # will not have duplicate denominators, and may slightly favor expressions
+ # with fewer additions and subtractions, as those are separated by spaces
+ # by the printer.
+
+ # Additional ideas for simplicity heuristics are welcome, like maybe
+ # checking if a equation has a larger domain, or if constantsimp has
+ # introduced arbitrary constants numbered higher than the order of a
+ # given ODE that sol is a solution of.
+ return len(str(sol))
+
+
+def _extract_funcs(eqs):
+ funcs = []
+ for eq in eqs:
+ derivs = [node for node in preorder_traversal(eq) if isinstance(node, Derivative)]
+ func = []
+ for d in derivs:
+ func += list(d.atoms(AppliedUndef))
+ for func_ in func:
+ funcs.append(func_)
+ funcs = list(uniq(funcs))
+
+ return funcs
+
+
+def _get_constant_subexpressions(expr, Cs):
+ Cs = set(Cs)
+ Ces = []
+ def _recursive_walk(expr):
+ expr_syms = expr.free_symbols
+ if expr_syms and expr_syms.issubset(Cs):
+ Ces.append(expr)
+ else:
+ if expr.func == exp:
+ expr = expr.expand(mul=True)
+ if expr.func in (Add, Mul):
+ d = sift(expr.args, lambda i : i.free_symbols.issubset(Cs))
+ if len(d[True]) > 1:
+ x = expr.func(*d[True])
+ if not x.is_number:
+ Ces.append(x)
+ elif isinstance(expr, Integral):
+ if expr.free_symbols.issubset(Cs) and \
+ all(len(x) == 3 for x in expr.limits):
+ Ces.append(expr)
+ for i in expr.args:
+ _recursive_walk(i)
+ return
+ _recursive_walk(expr)
+ return Ces
+
+def __remove_linear_redundancies(expr, Cs):
+ cnts = {i: expr.count(i) for i in Cs}
+ Cs = [i for i in Cs if cnts[i] > 0]
+
+ def _linear(expr):
+ if isinstance(expr, Add):
+ xs = [i for i in Cs if expr.count(i)==cnts[i] \
+ and 0 == expr.diff(i, 2)]
+ d = {}
+ for x in xs:
+ y = expr.diff(x)
+ if y not in d:
+ d[y]=[]
+ d[y].append(x)
+ for y in d:
+ if len(d[y]) > 1:
+ d[y].sort(key=str)
+ for x in d[y][1:]:
+ expr = expr.subs(x, 0)
+ return expr
+
+ def _recursive_walk(expr):
+ if len(expr.args) != 0:
+ expr = expr.func(*[_recursive_walk(i) for i in expr.args])
+ expr = _linear(expr)
+ return expr
+
+ if isinstance(expr, Equality):
+ lhs, rhs = [_recursive_walk(i) for i in expr.args]
+ f = lambda i: isinstance(i, Number) or i in Cs
+ if isinstance(lhs, Symbol) and lhs in Cs:
+ rhs, lhs = lhs, rhs
+ if lhs.func in (Add, Symbol) and rhs.func in (Add, Symbol):
+ dlhs = sift([lhs] if isinstance(lhs, AtomicExpr) else lhs.args, f)
+ drhs = sift([rhs] if isinstance(rhs, AtomicExpr) else rhs.args, f)
+ for i in [True, False]:
+ for hs in [dlhs, drhs]:
+ if i not in hs:
+ hs[i] = [0]
+ # this calculation can be simplified
+ lhs = Add(*dlhs[False]) - Add(*drhs[False])
+ rhs = Add(*drhs[True]) - Add(*dlhs[True])
+ elif lhs.func in (Mul, Symbol) and rhs.func in (Mul, Symbol):
+ dlhs = sift([lhs] if isinstance(lhs, AtomicExpr) else lhs.args, f)
+ if True in dlhs:
+ if False not in dlhs:
+ dlhs[False] = [1]
+ lhs = Mul(*dlhs[False])
+ rhs = rhs/Mul(*dlhs[True])
+ return Eq(lhs, rhs)
+ else:
+ return _recursive_walk(expr)
+
+@vectorize(0)
+def constantsimp(expr, constants):
+ r"""
+ Simplifies an expression with arbitrary constants in it.
+
+ This function is written specifically to work with
+ :py:meth:`~sympy.solvers.ode.dsolve`, and is not intended for general use.
+
+ Simplification is done by "absorbing" the arbitrary constants into other
+ arbitrary constants, numbers, and symbols that they are not independent
+ of.
+
+ The symbols must all have the same name with numbers after it, for
+ example, ``C1``, ``C2``, ``C3``. The ``symbolname`` here would be
+ '``C``', the ``startnumber`` would be 1, and the ``endnumber`` would be 3.
+ If the arbitrary constants are independent of the variable ``x``, then the
+ independent symbol would be ``x``. There is no need to specify the
+ dependent function, such as ``f(x)``, because it already has the
+ independent symbol, ``x``, in it.
+
+ Because terms are "absorbed" into arbitrary constants and because
+ constants are renumbered after simplifying, the arbitrary constants in
+ expr are not necessarily equal to the ones of the same name in the
+ returned result.
+
+ If two or more arbitrary constants are added, multiplied, or raised to the
+ power of each other, they are first absorbed together into a single
+ arbitrary constant. Then the new constant is combined into other terms if
+ necessary.
+
+ Absorption of constants is done with limited assistance:
+
+ 1. terms of :py:class:`~sympy.core.add.Add`\s are collected to try join
+ constants so `e^x (C_1 \cos(x) + C_2 \cos(x))` will simplify to `e^x
+ C_1 \cos(x)`;
+
+ 2. powers with exponents that are :py:class:`~sympy.core.add.Add`\s are
+ expanded so `e^{C_1 + x}` will be simplified to `C_1 e^x`.
+
+ Use :py:meth:`~sympy.solvers.ode.ode.constant_renumber` to renumber constants
+ after simplification or else arbitrary numbers on constants may appear,
+ e.g. `C_1 + C_3 x`.
+
+ In rare cases, a single constant can be "simplified" into two constants.
+ Every differential equation solution should have as many arbitrary
+ constants as the order of the differential equation. The result here will
+ be technically correct, but it may, for example, have `C_1` and `C_2` in
+ an expression, when `C_1` is actually equal to `C_2`. Use your discretion
+ in such situations, and also take advantage of the ability to use hints in
+ :py:meth:`~sympy.solvers.ode.dsolve`.
+
+ Examples
+ ========
+
+ >>> from sympy import symbols
+ >>> from sympy.solvers.ode.ode import constantsimp
+ >>> C1, C2, C3, x, y = symbols('C1, C2, C3, x, y')
+ >>> constantsimp(2*C1*x, {C1, C2, C3})
+ C1*x
+ >>> constantsimp(C1 + 2 + x, {C1, C2, C3})
+ C1 + x
+ >>> constantsimp(C1*C2 + 2 + C2 + C3*x, {C1, C2, C3})
+ C1 + C3*x
+
+ """
+ # This function works recursively. The idea is that, for Mul,
+ # Add, Pow, and Function, if the class has a constant in it, then
+ # we can simplify it, which we do by recursing down and
+ # simplifying up. Otherwise, we can skip that part of the
+ # expression.
+
+ Cs = constants
+
+ orig_expr = expr
+
+ constant_subexprs = _get_constant_subexpressions(expr, Cs)
+ for xe in constant_subexprs:
+ xes = list(xe.free_symbols)
+ if not xes:
+ continue
+ if all(expr.count(c) == xe.count(c) for c in xes):
+ xes.sort(key=str)
+ expr = expr.subs(xe, xes[0])
+
+ # try to perform common sub-expression elimination of constant terms
+ try:
+ commons, rexpr = cse(expr)
+ commons.reverse()
+ rexpr = rexpr[0]
+ for s in commons:
+ cs = list(s[1].atoms(Symbol))
+ if len(cs) == 1 and cs[0] in Cs and \
+ cs[0] not in rexpr.atoms(Symbol) and \
+ not any(cs[0] in ex for ex in commons if ex != s):
+ rexpr = rexpr.subs(s[0], cs[0])
+ else:
+ rexpr = rexpr.subs(*s)
+ expr = rexpr
+ except IndexError:
+ pass
+ expr = __remove_linear_redundancies(expr, Cs)
+
+ def _conditional_term_factoring(expr):
+ new_expr = terms_gcd(expr, clear=False, deep=True, expand=False)
+
+ # we do not want to factor exponentials, so handle this separately
+ if new_expr.is_Mul:
+ infac = False
+ asfac = False
+ for m in new_expr.args:
+ if isinstance(m, exp):
+ asfac = True
+ elif m.is_Add:
+ infac = any(isinstance(fi, exp) for t in m.args
+ for fi in Mul.make_args(t))
+ if asfac and infac:
+ new_expr = expr
+ break
+ return new_expr
+
+ expr = _conditional_term_factoring(expr)
+
+ # call recursively if more simplification is possible
+ if orig_expr != expr:
+ return constantsimp(expr, Cs)
+ return expr
+
+
+def constant_renumber(expr, variables=None, newconstants=None):
+ r"""
+ Renumber arbitrary constants in ``expr`` to use the symbol names as given
+ in ``newconstants``. In the process, this reorders expression terms in a
+ standard way.
+
+ If ``newconstants`` is not provided then the new constant names will be
+ ``C1``, ``C2`` etc. Otherwise ``newconstants`` should be an iterable
+ giving the new symbols to use for the constants in order.
+
+ The ``variables`` argument is a list of non-constant symbols. All other
+ free symbols found in ``expr`` are assumed to be constants and will be
+ renumbered. If ``variables`` is not given then any numbered symbol
+ beginning with ``C`` (e.g. ``C1``) is assumed to be a constant.
+
+ Symbols are renumbered based on ``.sort_key()``, so they should be
+ numbered roughly in the order that they appear in the final, printed
+ expression. Note that this ordering is based in part on hashes, so it can
+ produce different results on different machines.
+
+ The structure of this function is very similar to that of
+ :py:meth:`~sympy.solvers.ode.constantsimp`.
+
+ Examples
+ ========
+
+ >>> from sympy import symbols
+ >>> from sympy.solvers.ode.ode import constant_renumber
+ >>> x, C1, C2, C3 = symbols('x,C1:4')
+ >>> expr = C3 + C2*x + C1*x**2
+ >>> expr
+ C1*x**2 + C2*x + C3
+ >>> constant_renumber(expr)
+ C1 + C2*x + C3*x**2
+
+ The ``variables`` argument specifies which are constants so that the
+ other symbols will not be renumbered:
+
+ >>> constant_renumber(expr, [C1, x])
+ C1*x**2 + C2 + C3*x
+
+ The ``newconstants`` argument is used to specify what symbols to use when
+ replacing the constants:
+
+ >>> constant_renumber(expr, [x], newconstants=symbols('E1:4'))
+ E1 + E2*x + E3*x**2
+
+ """
+
+ # System of expressions
+ if isinstance(expr, (set, list, tuple)):
+ return type(expr)(constant_renumber(Tuple(*expr),
+ variables=variables, newconstants=newconstants))
+
+ # Symbols in solution but not ODE are constants
+ if variables is not None:
+ variables = set(variables)
+ free_symbols = expr.free_symbols
+ constantsymbols = list(free_symbols - variables)
+ # Any Cn is a constant...
+ else:
+ variables = set()
+ isconstant = lambda s: s.startswith('C') and s[1:].isdigit()
+ constantsymbols = [sym for sym in expr.free_symbols if isconstant(sym.name)]
+
+ # Find new constants checking that they aren't already in the ODE
+ if newconstants is None:
+ iter_constants = numbered_symbols(start=1, prefix='C', exclude=variables)
+ else:
+ iter_constants = (sym for sym in newconstants if sym not in variables)
+
+ constants_found = []
+
+ # make a mapping to send all constantsymbols to S.One and use
+ # that to make sure that term ordering is not dependent on
+ # the indexed value of C
+ C_1 = [(ci, S.One) for ci in constantsymbols]
+ sort_key=lambda arg: default_sort_key(arg.subs(C_1))
+
+ def _constant_renumber(expr):
+ r"""
+ We need to have an internal recursive function
+ """
+
+ # For system of expressions
+ if isinstance(expr, Tuple):
+ renumbered = [_constant_renumber(e) for e in expr]
+ return Tuple(*renumbered)
+
+ if isinstance(expr, Equality):
+ return Eq(
+ _constant_renumber(expr.lhs),
+ _constant_renumber(expr.rhs))
+
+ if type(expr) not in (Mul, Add, Pow) and not expr.is_Function and \
+ not expr.has(*constantsymbols):
+ # Base case, as above. Hope there aren't constants inside
+ # of some other class, because they won't be renumbered.
+ return expr
+ elif expr.is_Piecewise:
+ return expr
+ elif expr in constantsymbols:
+ if expr not in constants_found:
+ constants_found.append(expr)
+ return expr
+ elif expr.is_Function or expr.is_Pow:
+ return expr.func(
+ *[_constant_renumber(x) for x in expr.args])
+ else:
+ sortedargs = list(expr.args)
+ sortedargs.sort(key=sort_key)
+ return expr.func(*[_constant_renumber(x) for x in sortedargs])
+ expr = _constant_renumber(expr)
+
+ # Don't renumber symbols present in the ODE.
+ constants_found = [c for c in constants_found if c not in variables]
+
+ # Renumbering happens here
+ subs_dict = {var: cons for var, cons in zip(constants_found, iter_constants)}
+ expr = expr.subs(subs_dict, simultaneous=True)
+
+ return expr
+
+
+def _handle_Integral(expr, func, hint):
+ r"""
+ Converts a solution with Integrals in it into an actual solution.
+
+ For most hints, this simply runs ``expr.doit()``.
+
+ """
+ if hint == "nth_linear_constant_coeff_homogeneous":
+ sol = expr
+ elif not hint.endswith("_Integral"):
+ sol = expr.doit()
+ else:
+ sol = expr
+ return sol
+
+
+# XXX: Should this function maybe go somewhere else?
+
+
+def homogeneous_order(eq, *symbols):
+ r"""
+ Returns the order `n` if `g` is homogeneous and ``None`` if it is not
+ homogeneous.
+
+ Determines if a function is homogeneous and if so of what order. A
+ function `f(x, y, \cdots)` is homogeneous of order `n` if `f(t x, t y,
+ \cdots) = t^n f(x, y, \cdots)`.
+
+ If the function is of two variables, `F(x, y)`, then `f` being homogeneous
+ of any order is equivalent to being able to rewrite `F(x, y)` as `G(x/y)`
+ or `H(y/x)`. This fact is used to solve 1st order ordinary differential
+ equations whose coefficients are homogeneous of the same order (see the
+ docstrings of
+ :obj:`~sympy.solvers.ode.single.HomogeneousCoeffSubsDepDivIndep` and
+ :obj:`~sympy.solvers.ode.single.HomogeneousCoeffSubsIndepDivDep`).
+
+ Symbols can be functions, but every argument of the function must be a
+ symbol, and the arguments of the function that appear in the expression
+ must match those given in the list of symbols. If a declared function
+ appears with different arguments than given in the list of symbols,
+ ``None`` is returned.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, homogeneous_order, sqrt
+ >>> from sympy.abc import x, y
+ >>> f = Function('f')
+ >>> homogeneous_order(f(x), f(x)) is None
+ True
+ >>> homogeneous_order(f(x,y), f(y, x), x, y) is None
+ True
+ >>> homogeneous_order(f(x), f(x), x)
+ 1
+ >>> homogeneous_order(x**2*f(x)/sqrt(x**2+f(x)**2), x, f(x))
+ 2
+ >>> homogeneous_order(x**2+f(x), x, f(x)) is None
+ True
+
+ """
+
+ if not symbols:
+ raise ValueError("homogeneous_order: no symbols were given.")
+ symset = set(symbols)
+ eq = sympify(eq)
+
+ # The following are not supported
+ if eq.has(Order, Derivative):
+ return None
+
+ # These are all constants
+ if (eq.is_Number or
+ eq.is_NumberSymbol or
+ eq.is_number
+ ):
+ return S.Zero
+
+ # Replace all functions with dummy variables
+ dum = numbered_symbols(prefix='d', cls=Dummy)
+ newsyms = set()
+ for i in [j for j in symset if getattr(j, 'is_Function')]:
+ iargs = set(i.args)
+ if iargs.difference(symset):
+ return None
+ else:
+ dummyvar = next(dum)
+ eq = eq.subs(i, dummyvar)
+ symset.remove(i)
+ newsyms.add(dummyvar)
+ symset.update(newsyms)
+
+ if not eq.free_symbols & symset:
+ return None
+
+ # assuming order of a nested function can only be equal to zero
+ if isinstance(eq, Function):
+ return None if homogeneous_order(
+ eq.args[0], *tuple(symset)) != 0 else S.Zero
+
+ # make the replacement of x with x*t and see if t can be factored out
+ t = Dummy('t', positive=True) # It is sufficient that t > 0
+ eqs = separatevars(eq.subs([(i, t*i) for i in symset]), [t], dict=True)[t]
+ if eqs is S.One:
+ return S.Zero # there was no term with only t
+ i, d = eqs.as_independent(t, as_Add=False)
+ b, e = d.as_base_exp()
+ if b == t:
+ return e
+
+
+def ode_2nd_power_series_ordinary(eq, func, order, match):
+ r"""
+ Gives a power series solution to a second order homogeneous differential
+ equation with polynomial coefficients at an ordinary point. A homogeneous
+ differential equation is of the form
+
+ .. math :: P(x)\frac{d^2y}{dx^2} + Q(x)\frac{dy}{dx} + R(x) y(x) = 0
+
+ For simplicity it is assumed that `P(x)`, `Q(x)` and `R(x)` are polynomials,
+ it is sufficient that `\frac{Q(x)}{P(x)}` and `\frac{R(x)}{P(x)}` exists at
+ `x_{0}`. A recurrence relation is obtained by substituting `y` as `\sum_{n=0}^\infty a_{n}x^{n}`,
+ in the differential equation, and equating the nth term. Using this relation
+ various terms can be generated.
+
+
+ Examples
+ ========
+
+ >>> from sympy import dsolve, Function, pprint
+ >>> from sympy.abc import x
+ >>> f = Function("f")
+ >>> eq = f(x).diff(x, 2) + f(x)
+ >>> pprint(dsolve(eq, hint='2nd_power_series_ordinary'))
+ / 4 2 \ / 2\
+ |x x | | x | / 6\
+ f(x) = C2*|-- - -- + 1| + C1*x*|1 - --| + O\x /
+ \24 2 / \ 6 /
+
+
+ References
+ ==========
+ - https://tutorial.math.lamar.edu/Classes/DE/SeriesSolutions.aspx
+ - George E. Simmons, "Differential Equations with Applications and
+ Historical Notes", p.p 176 - 184
+
+ """
+ x = func.args[0]
+ f = func.func
+ C0, C1 = get_numbered_constants(eq, num=2)
+ n = Dummy("n", integer=True)
+ s = Wild("s")
+ k = Wild("k", exclude=[x])
+ x0 = match['x0']
+ terms = match['terms']
+ p = match[match['a3']]
+ q = match[match['b3']]
+ r = match[match['c3']]
+ seriesdict = {}
+ recurr = Function("r")
+
+ # Generating the recurrence relation which works this way:
+ # for the second order term the summation begins at n = 2. The coefficients
+ # p is multiplied with an*(n - 1)*(n - 2)*x**n-2 and a substitution is made such that
+ # the exponent of x becomes n.
+ # For example, if p is x, then the second degree recurrence term is
+ # an*(n - 1)*(n - 2)*x**n-1, substituting (n - 1) as n, it transforms to
+ # an+1*n*(n - 1)*x**n.
+ # A similar process is done with the first order and zeroth order term.
+
+ coefflist = [(recurr(n), r), (n*recurr(n), q), (n*(n - 1)*recurr(n), p)]
+ for index, coeff in enumerate(coefflist):
+ if coeff[1]:
+ f2 = powsimp(expand((coeff[1]*(x - x0)**(n - index)).subs(x, x + x0)))
+ if f2.is_Add:
+ addargs = f2.args
+ else:
+ addargs = [f2]
+ for arg in addargs:
+ powm = arg.match(s*x**k)
+ term = coeff[0]*powm[s]
+ if not powm[k].is_Symbol:
+ term = term.subs(n, n - powm[k].as_independent(n)[0])
+ startind = powm[k].subs(n, index)
+ # Seeing if the startterm can be reduced further.
+ # If it vanishes for n lesser than startind, it is
+ # equal to summation from n.
+ if startind:
+ for i in reversed(range(startind)):
+ if not term.subs(n, i):
+ seriesdict[term] = i
+ else:
+ seriesdict[term] = i + 1
+ break
+ else:
+ seriesdict[term] = S.Zero
+
+ # Stripping of terms so that the sum starts with the same number.
+ teq = S.Zero
+ suminit = seriesdict.values()
+ rkeys = seriesdict.keys()
+ req = Add(*rkeys)
+ if any(suminit):
+ maxval = max(suminit)
+ for term in seriesdict:
+ val = seriesdict[term]
+ if val != maxval:
+ for i in range(val, maxval):
+ teq += term.subs(n, val)
+
+ finaldict = {}
+ if teq:
+ fargs = teq.atoms(AppliedUndef)
+ if len(fargs) == 1:
+ finaldict[fargs.pop()] = 0
+ else:
+ maxf = max(fargs, key = lambda x: x.args[0])
+ sol = solve(teq, maxf)
+ if isinstance(sol, list):
+ sol = sol[0]
+ finaldict[maxf] = sol
+
+ # Finding the recurrence relation in terms of the largest term.
+ fargs = req.atoms(AppliedUndef)
+ maxf = max(fargs, key = lambda x: x.args[0])
+ minf = min(fargs, key = lambda x: x.args[0])
+ if minf.args[0].is_Symbol:
+ startiter = 0
+ else:
+ startiter = -minf.args[0].as_independent(n)[0]
+ lhs = maxf
+ rhs = solve(req, maxf)
+ if isinstance(rhs, list):
+ rhs = rhs[0]
+
+ # Checking how many values are already present
+ tcounter = len([t for t in finaldict.values() if t])
+
+ for _ in range(tcounter, terms - 3): # Assuming c0 and c1 to be arbitrary
+ check = rhs.subs(n, startiter)
+ nlhs = lhs.subs(n, startiter)
+ nrhs = check.subs(finaldict)
+ finaldict[nlhs] = nrhs
+ startiter += 1
+
+ # Post processing
+ series = C0 + C1*(x - x0)
+ for term in finaldict:
+ if finaldict[term]:
+ fact = term.args[0]
+ series += (finaldict[term].subs([(recurr(0), C0), (recurr(1), C1)])*(
+ x - x0)**fact)
+ series = collect(expand_mul(series), [C0, C1]) + Order(x**terms)
+ return Eq(f(x), series)
+
+
+def ode_2nd_power_series_regular(eq, func, order, match):
+ r"""
+ Gives a power series solution to a second order homogeneous differential
+ equation with polynomial coefficients at a regular point. A second order
+ homogeneous differential equation is of the form
+
+ .. math :: P(x)\frac{d^2y}{dx^2} + Q(x)\frac{dy}{dx} + R(x) y(x) = 0
+
+ A point is said to regular singular at `x0` if `x - x0\frac{Q(x)}{P(x)}`
+ and `(x - x0)^{2}\frac{R(x)}{P(x)}` are analytic at `x0`. For simplicity
+ `P(x)`, `Q(x)` and `R(x)` are assumed to be polynomials. The algorithm for
+ finding the power series solutions is:
+
+ 1. Try expressing `(x - x0)P(x)` and `((x - x0)^{2})Q(x)` as power series
+ solutions about x0. Find `p0` and `q0` which are the constants of the
+ power series expansions.
+ 2. Solve the indicial equation `f(m) = m(m - 1) + m*p0 + q0`, to obtain the
+ roots `m1` and `m2` of the indicial equation.
+ 3. If `m1 - m2` is a non integer there exists two series solutions. If
+ `m1 = m2`, there exists only one solution. If `m1 - m2` is an integer,
+ then the existence of one solution is confirmed. The other solution may
+ or may not exist.
+
+ The power series solution is of the form `x^{m}\sum_{n=0}^\infty a_{n}x^{n}`. The
+ coefficients are determined by the following recurrence relation.
+ `a_{n} = -\frac{\sum_{k=0}^{n-1} q_{n-k} + (m + k)p_{n-k}}{f(m + n)}`. For the case
+ in which `m1 - m2` is an integer, it can be seen from the recurrence relation
+ that for the lower root `m`, when `n` equals the difference of both the
+ roots, the denominator becomes zero. So if the numerator is not equal to zero,
+ a second series solution exists.
+
+
+ Examples
+ ========
+
+ >>> from sympy import dsolve, Function, pprint
+ >>> from sympy.abc import x
+ >>> f = Function("f")
+ >>> eq = x*(f(x).diff(x, 2)) + 2*(f(x).diff(x)) + x*f(x)
+ >>> pprint(dsolve(eq, hint='2nd_power_series_regular'))
+ / 6 4 2 \
+ | x x x |
+ / 4 2 \ C1*|- --- + -- - -- + 1|
+ | x x | \ 720 24 2 / / 6\
+ f(x) = C2*|--- - -- + 1| + ------------------------ + O\x /
+ \120 6 / x
+
+
+ References
+ ==========
+ - George E. Simmons, "Differential Equations with Applications and
+ Historical Notes", p.p 176 - 184
+
+ """
+ x = func.args[0]
+ f = func.func
+ C0, C1 = get_numbered_constants(eq, num=2)
+ m = Dummy("m") # for solving the indicial equation
+ x0 = match['x0']
+ terms = match['terms']
+ p = match['p']
+ q = match['q']
+
+ # Generating the indicial equation
+ indicial = []
+ for term in [p, q]:
+ if not term.has(x):
+ indicial.append(term)
+ else:
+ term = series(term, x=x, n=1, x0=x0)
+ if isinstance(term, Order):
+ indicial.append(S.Zero)
+ else:
+ for arg in term.args:
+ if not arg.has(x):
+ indicial.append(arg)
+ break
+
+ p0, q0 = indicial
+ sollist = solve(m*(m - 1) + m*p0 + q0, m)
+ if sollist and isinstance(sollist, list) and all(
+ sol.is_real for sol in sollist):
+ serdict1 = {}
+ serdict2 = {}
+ if len(sollist) == 1:
+ # Only one series solution exists in this case.
+ m1 = m2 = sollist.pop()
+ if terms-m1-1 <= 0:
+ return Eq(f(x), Order(terms))
+ serdict1 = _frobenius(terms-m1-1, m1, p0, q0, p, q, x0, x, C0)
+
+ else:
+ m1 = sollist[0]
+ m2 = sollist[1]
+ if m1 < m2:
+ m1, m2 = m2, m1
+ # Irrespective of whether m1 - m2 is an integer or not, one
+ # Frobenius series solution exists.
+ serdict1 = _frobenius(terms-m1-1, m1, p0, q0, p, q, x0, x, C0)
+ if not (m1 - m2).is_integer:
+ # Second frobenius series solution exists.
+ serdict2 = _frobenius(terms-m2-1, m2, p0, q0, p, q, x0, x, C1)
+ else:
+ # Check if second frobenius series solution exists.
+ serdict2 = _frobenius(terms-m2-1, m2, p0, q0, p, q, x0, x, C1, check=m1)
+
+ if serdict1:
+ finalseries1 = C0
+ for key in serdict1:
+ power = int(key.name[1:])
+ finalseries1 += serdict1[key]*(x - x0)**power
+ finalseries1 = (x - x0)**m1*finalseries1
+ finalseries2 = S.Zero
+ if serdict2:
+ for key in serdict2:
+ power = int(key.name[1:])
+ finalseries2 += serdict2[key]*(x - x0)**power
+ finalseries2 += C1
+ finalseries2 = (x - x0)**m2*finalseries2
+ return Eq(f(x), collect(finalseries1 + finalseries2,
+ [C0, C1]) + Order(x**terms))
+
+
+def _frobenius(n, m, p0, q0, p, q, x0, x, c, check=None):
+ r"""
+ Returns a dict with keys as coefficients and values as their values in terms of C0
+ """
+ n = int(n)
+ # In cases where m1 - m2 is not an integer
+ m2 = check
+
+ d = Dummy("d")
+ numsyms = numbered_symbols("C", start=0)
+ numsyms = [next(numsyms) for i in range(n + 1)]
+ serlist = []
+ for ser in [p, q]:
+ # Order term not present
+ if ser.is_polynomial(x) and Poly(ser, x).degree() <= n:
+ if x0:
+ ser = ser.subs(x, x + x0)
+ dict_ = Poly(ser, x).as_dict()
+ # Order term present
+ else:
+ tseries = series(ser, x=x0, n=n+1)
+ # Removing order
+ dict_ = Poly(list(ordered(tseries.args))[: -1], x).as_dict()
+ # Fill in with zeros, if coefficients are zero.
+ for i in range(n + 1):
+ if (i,) not in dict_:
+ dict_[(i,)] = S.Zero
+ serlist.append(dict_)
+
+ pseries = serlist[0]
+ qseries = serlist[1]
+ indicial = d*(d - 1) + d*p0 + q0
+ frobdict = {}
+ for i in range(1, n + 1):
+ num = c*(m*pseries[(i,)] + qseries[(i,)])
+ for j in range(1, i):
+ sym = Symbol("C" + str(j))
+ num += frobdict[sym]*((m + j)*pseries[(i - j,)] + qseries[(i - j,)])
+
+ # Checking for cases when m1 - m2 is an integer. If num equals zero
+ # then a second Frobenius series solution cannot be found. If num is not zero
+ # then set constant as zero and proceed.
+ if m2 is not None and i == m2 - m:
+ if num:
+ return False
+ else:
+ frobdict[numsyms[i]] = S.Zero
+ else:
+ frobdict[numsyms[i]] = -num/(indicial.subs(d, m+i))
+
+ return frobdict
+
+def _remove_redundant_solutions(eq, solns, order, var):
+ r"""
+ Remove redundant solutions from the set of solutions.
+
+ This function is needed because otherwise dsolve can return
+ redundant solutions. As an example consider:
+
+ eq = Eq((f(x).diff(x, 2))*f(x).diff(x), 0)
+
+ There are two ways to find solutions to eq. The first is to solve f(x).diff(x, 2) = 0
+ leading to solution f(x)=C1 + C2*x. The second is to solve the equation f(x).diff(x) = 0
+ leading to the solution f(x) = C1. In this particular case we then see
+ that the second solution is a special case of the first and we do not
+ want to return it.
+
+ This does not always happen. If we have
+
+ eq = Eq((f(x)**2-4)*(f(x).diff(x)-4), 0)
+
+ then we get the algebraic solution f(x) = [-2, 2] and the integral solution
+ f(x) = x + C1 and in this case the two solutions are not equivalent wrt
+ initial conditions so both should be returned.
+ """
+ def is_special_case_of(soln1, soln2):
+ return _is_special_case_of(soln1, soln2, eq, order, var)
+
+ unique_solns = []
+ for soln1 in solns:
+ for soln2 in unique_solns[:]:
+ if is_special_case_of(soln1, soln2):
+ break
+ elif is_special_case_of(soln2, soln1):
+ unique_solns.remove(soln2)
+ else:
+ unique_solns.append(soln1)
+
+ return unique_solns
+
+def _is_special_case_of(soln1, soln2, eq, order, var):
+ r"""
+ True if soln1 is found to be a special case of soln2 wrt some value of the
+ constants that appear in soln2. False otherwise.
+ """
+ # The solutions returned by dsolve may be given explicitly or implicitly.
+ # We will equate the sol1=(soln1.rhs - soln1.lhs), sol2=(soln2.rhs - soln2.lhs)
+ # of the two solutions.
+ #
+ # Since this is supposed to hold for all x it also holds for derivatives.
+ # For an order n ode we should be able to differentiate
+ # each solution n times to get n+1 equations.
+ #
+ # We then try to solve those n+1 equations for the integrations constants
+ # in sol2. If we can find a solution that does not depend on x then it
+ # means that some value of the constants in sol1 is a special case of
+ # sol2 corresponding to a particular choice of the integration constants.
+
+ # In case the solution is in implicit form we subtract the sides
+ soln1 = soln1.rhs - soln1.lhs
+ soln2 = soln2.rhs - soln2.lhs
+
+ # Work for the series solution
+ if soln1.has(Order) and soln2.has(Order):
+ if soln1.getO() == soln2.getO():
+ soln1 = soln1.removeO()
+ soln2 = soln2.removeO()
+ else:
+ return False
+ elif soln1.has(Order) or soln2.has(Order):
+ return False
+
+ constants1 = soln1.free_symbols.difference(eq.free_symbols)
+ constants2 = soln2.free_symbols.difference(eq.free_symbols)
+
+ constants1_new = get_numbered_constants(Tuple(soln1, soln2), len(constants1))
+ if len(constants1) == 1:
+ constants1_new = {constants1_new}
+ for c_old, c_new in zip(constants1, constants1_new):
+ soln1 = soln1.subs(c_old, c_new)
+
+ # n equations for sol1 = sol2, sol1'=sol2', ...
+ lhs = soln1
+ rhs = soln2
+ eqns = [Eq(lhs, rhs)]
+ for n in range(1, order):
+ lhs = lhs.diff(var)
+ rhs = rhs.diff(var)
+ eq = Eq(lhs, rhs)
+ eqns.append(eq)
+
+ # BooleanTrue/False awkwardly show up for trivial equations
+ if any(isinstance(eq, BooleanFalse) for eq in eqns):
+ return False
+ eqns = [eq for eq in eqns if not isinstance(eq, BooleanTrue)]
+
+ try:
+ constant_solns = solve(eqns, constants2)
+ except NotImplementedError:
+ return False
+
+ # Sometimes returns a dict and sometimes a list of dicts
+ if isinstance(constant_solns, dict):
+ constant_solns = [constant_solns]
+
+ # after solving the issue 17418, maybe we don't need the following checksol code.
+ for constant_soln in constant_solns:
+ for eq in eqns:
+ eq=eq.rhs-eq.lhs
+ if checksol(eq, constant_soln) is not True:
+ return False
+
+ # If any solution gives all constants as expressions that don't depend on
+ # x then there exists constants for soln2 that give soln1
+ for constant_soln in constant_solns:
+ if not any(c.has(var) for c in constant_soln.values()):
+ return True
+
+ return False
+
+
+def ode_1st_power_series(eq, func, order, match):
+ r"""
+ The power series solution is a method which gives the Taylor series expansion
+ to the solution of a differential equation.
+
+ For a first order differential equation `\frac{dy}{dx} = h(x, y)`, a power
+ series solution exists at a point `x = x_{0}` if `h(x, y)` is analytic at `x_{0}`.
+ The solution is given by
+
+ .. math:: y(x) = y(x_{0}) + \sum_{n = 1}^{\infty} \frac{F_{n}(x_{0},b)(x - x_{0})^n}{n!},
+
+ where `y(x_{0}) = b` is the value of y at the initial value of `x_{0}`.
+ To compute the values of the `F_{n}(x_{0},b)` the following algorithm is
+ followed, until the required number of terms are generated.
+
+ 1. `F_1 = h(x_{0}, b)`
+ 2. `F_{n+1} = \frac{\partial F_{n}}{\partial x} + \frac{\partial F_{n}}{\partial y}F_{1}`
+
+ Examples
+ ========
+
+ >>> from sympy import Function, pprint, exp, dsolve
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> eq = exp(x)*(f(x).diff(x)) - f(x)
+ >>> pprint(dsolve(eq, hint='1st_power_series'))
+ 3 4 5
+ C1*x C1*x C1*x / 6\
+ f(x) = C1 + C1*x - ----- + ----- + ----- + O\x /
+ 6 24 60
+
+
+ References
+ ==========
+
+ - Travis W. Walker, Analytic power series technique for solving first-order
+ differential equations, p.p 17, 18
+
+ """
+ x = func.args[0]
+ y = match['y']
+ f = func.func
+ h = -match[match['d']]/match[match['e']]
+ point = match['f0']
+ value = match['f0val']
+ terms = match['terms']
+
+ # First term
+ F = h
+ if not h:
+ return Eq(f(x), value)
+
+ # Initialization
+ series = value
+ if terms > 1:
+ hc = h.subs({x: point, y: value})
+ if hc.has(oo) or hc.has(nan) or hc.has(zoo):
+ # Derivative does not exist, not analytic
+ return Eq(f(x), oo)
+ elif hc:
+ series += hc*(x - point)
+
+ for factcount in range(2, terms):
+ Fnew = F.diff(x) + F.diff(y)*h
+ Fnewc = Fnew.subs({x: point, y: value})
+ # Same logic as above
+ if Fnewc.has(oo) or Fnewc.has(nan) or Fnewc.has(-oo) or Fnewc.has(zoo):
+ return Eq(f(x), oo)
+ series += Fnewc*((x - point)**factcount)/factorial(factcount)
+ F = Fnew
+ series += Order(x**terms)
+ return Eq(f(x), series)
+
+
+def checkinfsol(eq, infinitesimals, func=None, order=None):
+ r"""
+ This function is used to check if the given infinitesimals are the
+ actual infinitesimals of the given first order differential equation.
+ This method is specific to the Lie Group Solver of ODEs.
+
+ As of now, it simply checks, by substituting the infinitesimals in the
+ partial differential equation.
+
+
+ .. math:: \frac{\partial \eta}{\partial x} + \left(\frac{\partial \eta}{\partial y}
+ - \frac{\partial \xi}{\partial x}\right)*h
+ - \frac{\partial \xi}{\partial y}*h^{2}
+ - \xi\frac{\partial h}{\partial x} - \eta\frac{\partial h}{\partial y} = 0
+
+
+ where `\eta`, and `\xi` are the infinitesimals and `h(x,y) = \frac{dy}{dx}`
+
+ The infinitesimals should be given in the form of a list of dicts
+ ``[{xi(x, y): inf, eta(x, y): inf}]``, corresponding to the
+ output of the function infinitesimals. It returns a list
+ of values of the form ``[(True/False, sol)]`` where ``sol`` is the value
+ obtained after substituting the infinitesimals in the PDE. If it
+ is ``True``, then ``sol`` would be 0.
+
+ """
+ if isinstance(eq, Equality):
+ eq = eq.lhs - eq.rhs
+ if not func:
+ eq, func = _preprocess(eq)
+ variables = func.args
+ if len(variables) != 1:
+ raise ValueError("ODE's have only one independent variable")
+ else:
+ x = variables[0]
+ if not order:
+ order = ode_order(eq, func)
+ if order != 1:
+ raise NotImplementedError("Lie groups solver has been implemented "
+ "only for first order differential equations")
+ else:
+ df = func.diff(x)
+ a = Wild('a', exclude = [df])
+ b = Wild('b', exclude = [df])
+ match = collect(expand(eq), df).match(a*df + b)
+
+ if match:
+ h = -simplify(match[b]/match[a])
+ else:
+ try:
+ sol = solve(eq, df)
+ except NotImplementedError:
+ raise NotImplementedError("Infinitesimals for the "
+ "first order ODE could not be found")
+ else:
+ h = sol[0] # Find infinitesimals for one solution
+
+ y = Dummy('y')
+ h = h.subs(func, y)
+ xi = Function('xi')(x, y)
+ eta = Function('eta')(x, y)
+ dxi = Function('xi')(x, func)
+ deta = Function('eta')(x, func)
+ pde = (eta.diff(x) + (eta.diff(y) - xi.diff(x))*h -
+ (xi.diff(y))*h**2 - xi*(h.diff(x)) - eta*(h.diff(y)))
+ soltup = []
+ for sol in infinitesimals:
+ tsol = {xi: S(sol[dxi]).subs(func, y),
+ eta: S(sol[deta]).subs(func, y)}
+ sol = simplify(pde.subs(tsol).doit())
+ if sol:
+ soltup.append((False, sol.subs(y, func)))
+ else:
+ soltup.append((True, 0))
+ return soltup
+
+
+def sysode_linear_2eq_order1(match_):
+ x = match_['func'][0].func
+ y = match_['func'][1].func
+ func = match_['func']
+ fc = match_['func_coeff']
+ eq = match_['eq']
+ r = {}
+ t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+ for i in range(2):
+ eq[i] = Add(*[terms/fc[i,func[i],1] for terms in Add.make_args(eq[i])])
+
+ # for equations Eq(a1*diff(x(t),t), a*x(t) + b*y(t) + k1)
+ # and Eq(a2*diff(x(t),t), c*x(t) + d*y(t) + k2)
+ r['a'] = -fc[0,x(t),0]/fc[0,x(t),1]
+ r['c'] = -fc[1,x(t),0]/fc[1,y(t),1]
+ r['b'] = -fc[0,y(t),0]/fc[0,x(t),1]
+ r['d'] = -fc[1,y(t),0]/fc[1,y(t),1]
+ forcing = [S.Zero,S.Zero]
+ for i in range(2):
+ for j in Add.make_args(eq[i]):
+ if not j.has(x(t), y(t)):
+ forcing[i] += j
+ if not (forcing[0].has(t) or forcing[1].has(t)):
+ r['k1'] = forcing[0]
+ r['k2'] = forcing[1]
+ else:
+ raise NotImplementedError("Only homogeneous problems are supported" +
+ " (and constant inhomogeneity)")
+
+ if match_['type_of_equation'] == 'type6':
+ sol = _linear_2eq_order1_type6(x, y, t, r, eq)
+ if match_['type_of_equation'] == 'type7':
+ sol = _linear_2eq_order1_type7(x, y, t, r, eq)
+ return sol
+
+def _linear_2eq_order1_type6(x, y, t, r, eq):
+ r"""
+ The equations of this type of ode are .
+
+ .. math:: x' = f(t) x + g(t) y
+
+ .. math:: y' = a [f(t) + a h(t)] x + a [g(t) - h(t)] y
+
+ This is solved by first multiplying the first equation by `-a` and adding
+ it to the second equation to obtain
+
+ .. math:: y' - a x' = -a h(t) (y - a x)
+
+ Setting `U = y - ax` and integrating the equation we arrive at
+
+ .. math:: y - ax = C_1 e^{-a \int h(t) \,dt}
+
+ and on substituting the value of y in first equation give rise to first order ODEs. After solving for
+ `x`, we can obtain `y` by substituting the value of `x` in second equation.
+
+ """
+ C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
+ p = 0
+ q = 0
+ p1 = cancel(r['c']/cancel(r['c']/r['d']).as_numer_denom()[0])
+ p2 = cancel(r['a']/cancel(r['a']/r['b']).as_numer_denom()[0])
+ for n, i in enumerate([p1, p2]):
+ for j in Mul.make_args(collect_const(i)):
+ if not j.has(t):
+ q = j
+ if q!=0 and n==0:
+ if ((r['c']/j - r['a'])/(r['b'] - r['d']/j)) == j:
+ p = 1
+ s = j
+ break
+ if q!=0 and n==1:
+ if ((r['a']/j - r['c'])/(r['d'] - r['b']/j)) == j:
+ p = 2
+ s = j
+ break
+
+ if p == 1:
+ equ = diff(x(t),t) - r['a']*x(t) - r['b']*(s*x(t) + C1*exp(-s*Integral(r['b'] - r['d']/s, t)))
+ hint1 = classify_ode(equ)[1]
+ sol1 = dsolve(equ, hint=hint1+'_Integral').rhs
+ sol2 = s*sol1 + C1*exp(-s*Integral(r['b'] - r['d']/s, t))
+ elif p ==2:
+ equ = diff(y(t),t) - r['c']*y(t) - r['d']*s*y(t) + C1*exp(-s*Integral(r['d'] - r['b']/s, t))
+ hint1 = classify_ode(equ)[1]
+ sol2 = dsolve(equ, hint=hint1+'_Integral').rhs
+ sol1 = s*sol2 + C1*exp(-s*Integral(r['d'] - r['b']/s, t))
+ return [Eq(x(t), sol1), Eq(y(t), sol2)]
+
+def _linear_2eq_order1_type7(x, y, t, r, eq):
+ r"""
+ The equations of this type of ode are .
+
+ .. math:: x' = f(t) x + g(t) y
+
+ .. math:: y' = h(t) x + p(t) y
+
+ Differentiating the first equation and substituting the value of `y`
+ from second equation will give a second-order linear equation
+
+ .. math:: g x'' - (fg + gp + g') x' + (fgp - g^{2} h + f g' - f' g) x = 0
+
+ This above equation can be easily integrated if following conditions are satisfied.
+
+ 1. `fgp - g^{2} h + f g' - f' g = 0`
+
+ 2. `fgp - g^{2} h + f g' - f' g = ag, fg + gp + g' = bg`
+
+ If first condition is satisfied then it is solved by current dsolve solver and in second case it becomes
+ a constant coefficient differential equation which is also solved by current solver.
+
+ Otherwise if the above condition fails then,
+ a particular solution is assumed as `x = x_0(t)` and `y = y_0(t)`
+ Then the general solution is expressed as
+
+ .. math:: x = C_1 x_0(t) + C_2 x_0(t) \int \frac{g(t) F(t) P(t)}{x_0^{2}(t)} \,dt
+
+ .. math:: y = C_1 y_0(t) + C_2 [\frac{F(t) P(t)}{x_0(t)} + y_0(t) \int \frac{g(t) F(t) P(t)}{x_0^{2}(t)} \,dt]
+
+ where C1 and C2 are arbitrary constants and
+
+ .. math:: F(t) = e^{\int f(t) \,dt}, P(t) = e^{\int p(t) \,dt}
+
+ """
+ C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
+ e1 = r['a']*r['b']*r['c'] - r['b']**2*r['c'] + r['a']*diff(r['b'],t) - diff(r['a'],t)*r['b']
+ e2 = r['a']*r['c']*r['d'] - r['b']*r['c']**2 + diff(r['c'],t)*r['d'] - r['c']*diff(r['d'],t)
+ m1 = r['a']*r['b'] + r['b']*r['d'] + diff(r['b'],t)
+ m2 = r['a']*r['c'] + r['c']*r['d'] + diff(r['c'],t)
+ if e1 == 0:
+ sol1 = dsolve(r['b']*diff(x(t),t,t) - m1*diff(x(t),t)).rhs
+ sol2 = dsolve(diff(y(t),t) - r['c']*sol1 - r['d']*y(t)).rhs
+ elif e2 == 0:
+ sol2 = dsolve(r['c']*diff(y(t),t,t) - m2*diff(y(t),t)).rhs
+ sol1 = dsolve(diff(x(t),t) - r['a']*x(t) - r['b']*sol2).rhs
+ elif not (e1/r['b']).has(t) and not (m1/r['b']).has(t):
+ sol1 = dsolve(diff(x(t),t,t) - (m1/r['b'])*diff(x(t),t) - (e1/r['b'])*x(t)).rhs
+ sol2 = dsolve(diff(y(t),t) - r['c']*sol1 - r['d']*y(t)).rhs
+ elif not (e2/r['c']).has(t) and not (m2/r['c']).has(t):
+ sol2 = dsolve(diff(y(t),t,t) - (m2/r['c'])*diff(y(t),t) - (e2/r['c'])*y(t)).rhs
+ sol1 = dsolve(diff(x(t),t) - r['a']*x(t) - r['b']*sol2).rhs
+ else:
+ x0 = Function('x0')(t) # x0 and y0 being particular solutions
+ y0 = Function('y0')(t)
+ F = exp(Integral(r['a'],t))
+ P = exp(Integral(r['d'],t))
+ sol1 = C1*x0 + C2*x0*Integral(r['b']*F*P/x0**2, t)
+ sol2 = C1*y0 + C2*(F*P/x0 + y0*Integral(r['b']*F*P/x0**2, t))
+ return [Eq(x(t), sol1), Eq(y(t), sol2)]
+
+
+def sysode_nonlinear_2eq_order1(match_):
+ func = match_['func']
+ eq = match_['eq']
+ fc = match_['func_coeff']
+ t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+ if match_['type_of_equation'] == 'type5':
+ sol = _nonlinear_2eq_order1_type5(func, t, eq)
+ return sol
+ x = func[0].func
+ y = func[1].func
+ for i in range(2):
+ eqs = 0
+ for terms in Add.make_args(eq[i]):
+ eqs += terms/fc[i,func[i],1]
+ eq[i] = eqs
+ if match_['type_of_equation'] == 'type1':
+ sol = _nonlinear_2eq_order1_type1(x, y, t, eq)
+ elif match_['type_of_equation'] == 'type2':
+ sol = _nonlinear_2eq_order1_type2(x, y, t, eq)
+ elif match_['type_of_equation'] == 'type3':
+ sol = _nonlinear_2eq_order1_type3(x, y, t, eq)
+ elif match_['type_of_equation'] == 'type4':
+ sol = _nonlinear_2eq_order1_type4(x, y, t, eq)
+ return sol
+
+
+def _nonlinear_2eq_order1_type1(x, y, t, eq):
+ r"""
+ Equations:
+
+ .. math:: x' = x^n F(x,y)
+
+ .. math:: y' = g(y) F(x,y)
+
+ Solution:
+
+ .. math:: x = \varphi(y), \int \frac{1}{g(y) F(\varphi(y),y)} \,dy = t + C_2
+
+ where
+
+ if `n \neq 1`
+
+ .. math:: \varphi = [C_1 + (1-n) \int \frac{1}{g(y)} \,dy]^{\frac{1}{1-n}}
+
+ if `n = 1`
+
+ .. math:: \varphi = C_1 e^{\int \frac{1}{g(y)} \,dy}
+
+ where `C_1` and `C_2` are arbitrary constants.
+
+ """
+ C1, C2 = get_numbered_constants(eq, num=2)
+ n = Wild('n', exclude=[x(t),y(t)])
+ f = Wild('f')
+ u, v = symbols('u, v')
+ r = eq[0].match(diff(x(t),t) - x(t)**n*f)
+ g = ((diff(y(t),t) - eq[1])/r[f]).subs(y(t),v)
+ F = r[f].subs(x(t),u).subs(y(t),v)
+ n = r[n]
+ if n!=1:
+ phi = (C1 + (1-n)*Integral(1/g, v))**(1/(1-n))
+ else:
+ phi = C1*exp(Integral(1/g, v))
+ phi = phi.doit()
+ sol2 = solve(Integral(1/(g*F.subs(u,phi)), v).doit() - t - C2, v)
+ sol = []
+ for sols in sol2:
+ sol.append(Eq(x(t),phi.subs(v, sols)))
+ sol.append(Eq(y(t), sols))
+ return sol
+
+def _nonlinear_2eq_order1_type2(x, y, t, eq):
+ r"""
+ Equations:
+
+ .. math:: x' = e^{\lambda x} F(x,y)
+
+ .. math:: y' = g(y) F(x,y)
+
+ Solution:
+
+ .. math:: x = \varphi(y), \int \frac{1}{g(y) F(\varphi(y),y)} \,dy = t + C_2
+
+ where
+
+ if `\lambda \neq 0`
+
+ .. math:: \varphi = -\frac{1}{\lambda} log(C_1 - \lambda \int \frac{1}{g(y)} \,dy)
+
+ if `\lambda = 0`
+
+ .. math:: \varphi = C_1 + \int \frac{1}{g(y)} \,dy
+
+ where `C_1` and `C_2` are arbitrary constants.
+
+ """
+ C1, C2 = get_numbered_constants(eq, num=2)
+ n = Wild('n', exclude=[x(t),y(t)])
+ f = Wild('f')
+ u, v = symbols('u, v')
+ r = eq[0].match(diff(x(t),t) - exp(n*x(t))*f)
+ g = ((diff(y(t),t) - eq[1])/r[f]).subs(y(t),v)
+ F = r[f].subs(x(t),u).subs(y(t),v)
+ n = r[n]
+ if n:
+ phi = -1/n*log(C1 - n*Integral(1/g, v))
+ else:
+ phi = C1 + Integral(1/g, v)
+ phi = phi.doit()
+ sol2 = solve(Integral(1/(g*F.subs(u,phi)), v).doit() - t - C2, v)
+ sol = []
+ for sols in sol2:
+ sol.append(Eq(x(t),phi.subs(v, sols)))
+ sol.append(Eq(y(t), sols))
+ return sol
+
+def _nonlinear_2eq_order1_type3(x, y, t, eq):
+ r"""
+ Autonomous system of general form
+
+ .. math:: x' = F(x,y)
+
+ .. math:: y' = G(x,y)
+
+ Assuming `y = y(x, C_1)` where `C_1` is an arbitrary constant is the general
+ solution of the first-order equation
+
+ .. math:: F(x,y) y'_x = G(x,y)
+
+ Then the general solution of the original system of equations has the form
+
+ .. math:: \int \frac{1}{F(x,y(x,C_1))} \,dx = t + C_1
+
+ """
+ C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
+ v = Function('v')
+ u = Symbol('u')
+ f = Wild('f')
+ g = Wild('g')
+ r1 = eq[0].match(diff(x(t),t) - f)
+ r2 = eq[1].match(diff(y(t),t) - g)
+ F = r1[f].subs(x(t), u).subs(y(t), v(u))
+ G = r2[g].subs(x(t), u).subs(y(t), v(u))
+ sol2r = dsolve(Eq(diff(v(u), u), G/F))
+ if isinstance(sol2r, Equality):
+ sol2r = [sol2r]
+ for sol2s in sol2r:
+ sol1 = solve(Integral(1/F.subs(v(u), sol2s.rhs), u).doit() - t - C2, u)
+ sol = []
+ for sols in sol1:
+ sol.append(Eq(x(t), sols))
+ sol.append(Eq(y(t), (sol2s.rhs).subs(u, sols)))
+ return sol
+
+def _nonlinear_2eq_order1_type4(x, y, t, eq):
+ r"""
+ Equation:
+
+ .. math:: x' = f_1(x) g_1(y) \phi(x,y,t)
+
+ .. math:: y' = f_2(x) g_2(y) \phi(x,y,t)
+
+ First integral:
+
+ .. math:: \int \frac{f_2(x)}{f_1(x)} \,dx - \int \frac{g_1(y)}{g_2(y)} \,dy = C
+
+ where `C` is an arbitrary constant.
+
+ On solving the first integral for `x` (resp., `y` ) and on substituting the
+ resulting expression into either equation of the original solution, one
+ arrives at a first-order equation for determining `y` (resp., `x` ).
+
+ """
+ C1, C2 = get_numbered_constants(eq, num=2)
+ u, v = symbols('u, v')
+ U, V = symbols('U, V', cls=Function)
+ f = Wild('f')
+ g = Wild('g')
+ f1 = Wild('f1', exclude=[v,t])
+ f2 = Wild('f2', exclude=[v,t])
+ g1 = Wild('g1', exclude=[u,t])
+ g2 = Wild('g2', exclude=[u,t])
+ r1 = eq[0].match(diff(x(t),t) - f)
+ r2 = eq[1].match(diff(y(t),t) - g)
+ num, den = (
+ (r1[f].subs(x(t),u).subs(y(t),v))/
+ (r2[g].subs(x(t),u).subs(y(t),v))).as_numer_denom()
+ R1 = num.match(f1*g1)
+ R2 = den.match(f2*g2)
+ phi = (r1[f].subs(x(t),u).subs(y(t),v))/num
+ F1 = R1[f1]; F2 = R2[f2]
+ G1 = R1[g1]; G2 = R2[g2]
+ sol1r = solve(Integral(F2/F1, u).doit() - Integral(G1/G2,v).doit() - C1, u)
+ sol2r = solve(Integral(F2/F1, u).doit() - Integral(G1/G2,v).doit() - C1, v)
+ sol = []
+ for sols in sol1r:
+ sol.append(Eq(y(t), dsolve(diff(V(t),t) - F2.subs(u,sols).subs(v,V(t))*G2.subs(v,V(t))*phi.subs(u,sols).subs(v,V(t))).rhs))
+ for sols in sol2r:
+ sol.append(Eq(x(t), dsolve(diff(U(t),t) - F1.subs(u,U(t))*G1.subs(v,sols).subs(u,U(t))*phi.subs(v,sols).subs(u,U(t))).rhs))
+ return set(sol)
+
+def _nonlinear_2eq_order1_type5(func, t, eq):
+ r"""
+ Clairaut system of ODEs
+
+ .. math:: x = t x' + F(x',y')
+
+ .. math:: y = t y' + G(x',y')
+
+ The following are solutions of the system
+
+ `(i)` straight lines:
+
+ .. math:: x = C_1 t + F(C_1, C_2), y = C_2 t + G(C_1, C_2)
+
+ where `C_1` and `C_2` are arbitrary constants;
+
+ `(ii)` envelopes of the above lines;
+
+ `(iii)` continuously differentiable lines made up from segments of the lines
+ `(i)` and `(ii)`.
+
+ """
+ C1, C2 = get_numbered_constants(eq, num=2)
+ f = Wild('f')
+ g = Wild('g')
+ def check_type(x, y):
+ r1 = eq[0].match(t*diff(x(t),t) - x(t) + f)
+ r2 = eq[1].match(t*diff(y(t),t) - y(t) + g)
+ if not (r1 and r2):
+ r1 = eq[0].match(diff(x(t),t) - x(t)/t + f/t)
+ r2 = eq[1].match(diff(y(t),t) - y(t)/t + g/t)
+ if not (r1 and r2):
+ r1 = (-eq[0]).match(t*diff(x(t),t) - x(t) + f)
+ r2 = (-eq[1]).match(t*diff(y(t),t) - y(t) + g)
+ if not (r1 and r2):
+ r1 = (-eq[0]).match(diff(x(t),t) - x(t)/t + f/t)
+ r2 = (-eq[1]).match(diff(y(t),t) - y(t)/t + g/t)
+ return [r1, r2]
+ for func_ in func:
+ if isinstance(func_, list):
+ x = func[0][0].func
+ y = func[0][1].func
+ [r1, r2] = check_type(x, y)
+ if not (r1 and r2):
+ [r1, r2] = check_type(y, x)
+ x, y = y, x
+ x1 = diff(x(t),t); y1 = diff(y(t),t)
+ return {Eq(x(t), C1*t + r1[f].subs(x1,C1).subs(y1,C2)), Eq(y(t), C2*t + r2[g].subs(x1,C1).subs(y1,C2))}
+
+def sysode_nonlinear_3eq_order1(match_):
+ x = match_['func'][0].func
+ y = match_['func'][1].func
+ z = match_['func'][2].func
+ eq = match_['eq']
+ t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+ if match_['type_of_equation'] == 'type1':
+ sol = _nonlinear_3eq_order1_type1(x, y, z, t, eq)
+ if match_['type_of_equation'] == 'type2':
+ sol = _nonlinear_3eq_order1_type2(x, y, z, t, eq)
+ if match_['type_of_equation'] == 'type3':
+ sol = _nonlinear_3eq_order1_type3(x, y, z, t, eq)
+ if match_['type_of_equation'] == 'type4':
+ sol = _nonlinear_3eq_order1_type4(x, y, z, t, eq)
+ if match_['type_of_equation'] == 'type5':
+ sol = _nonlinear_3eq_order1_type5(x, y, z, t, eq)
+ return sol
+
+def _nonlinear_3eq_order1_type1(x, y, z, t, eq):
+ r"""
+ Equations:
+
+ .. math:: a x' = (b - c) y z, \enspace b y' = (c - a) z x, \enspace c z' = (a - b) x y
+
+ First Integrals:
+
+ .. math:: a x^{2} + b y^{2} + c z^{2} = C_1
+
+ .. math:: a^{2} x^{2} + b^{2} y^{2} + c^{2} z^{2} = C_2
+
+ where `C_1` and `C_2` are arbitrary constants. On solving the integrals for `y` and
+ `z` and on substituting the resulting expressions into the first equation of the
+ system, we arrives at a separable first-order equation on `x`. Similarly doing that
+ for other two equations, we will arrive at first order equation on `y` and `z` too.
+
+ References
+ ==========
+ -https://eqworld.ipmnet.ru/en/solutions/sysode/sode0401.pdf
+
+ """
+ C1, C2 = get_numbered_constants(eq, num=2)
+ u, v, w = symbols('u, v, w')
+ p = Wild('p', exclude=[x(t), y(t), z(t), t])
+ q = Wild('q', exclude=[x(t), y(t), z(t), t])
+ s = Wild('s', exclude=[x(t), y(t), z(t), t])
+ r = (diff(x(t),t) - eq[0]).match(p*y(t)*z(t))
+ r.update((diff(y(t),t) - eq[1]).match(q*z(t)*x(t)))
+ r.update((diff(z(t),t) - eq[2]).match(s*x(t)*y(t)))
+ n1, d1 = r[p].as_numer_denom()
+ n2, d2 = r[q].as_numer_denom()
+ n3, d3 = r[s].as_numer_denom()
+ val = solve([n1*u-d1*v+d1*w, d2*u+n2*v-d2*w, d3*u-d3*v-n3*w],[u,v])
+ vals = [val[v], val[u]]
+ c = lcm(vals[0].as_numer_denom()[1], vals[1].as_numer_denom()[1])
+ b = vals[0].subs(w, c)
+ a = vals[1].subs(w, c)
+ y_x = sqrt(((c*C1-C2) - a*(c-a)*x(t)**2)/(b*(c-b)))
+ z_x = sqrt(((b*C1-C2) - a*(b-a)*x(t)**2)/(c*(b-c)))
+ z_y = sqrt(((a*C1-C2) - b*(a-b)*y(t)**2)/(c*(a-c)))
+ x_y = sqrt(((c*C1-C2) - b*(c-b)*y(t)**2)/(a*(c-a)))
+ x_z = sqrt(((b*C1-C2) - c*(b-c)*z(t)**2)/(a*(b-a)))
+ y_z = sqrt(((a*C1-C2) - c*(a-c)*z(t)**2)/(b*(a-b)))
+ sol1 = dsolve(a*diff(x(t),t) - (b-c)*y_x*z_x)
+ sol2 = dsolve(b*diff(y(t),t) - (c-a)*z_y*x_y)
+ sol3 = dsolve(c*diff(z(t),t) - (a-b)*x_z*y_z)
+ return [sol1, sol2, sol3]
+
+
+def _nonlinear_3eq_order1_type2(x, y, z, t, eq):
+ r"""
+ Equations:
+
+ .. math:: a x' = (b - c) y z f(x, y, z, t)
+
+ .. math:: b y' = (c - a) z x f(x, y, z, t)
+
+ .. math:: c z' = (a - b) x y f(x, y, z, t)
+
+ First Integrals:
+
+ .. math:: a x^{2} + b y^{2} + c z^{2} = C_1
+
+ .. math:: a^{2} x^{2} + b^{2} y^{2} + c^{2} z^{2} = C_2
+
+ where `C_1` and `C_2` are arbitrary constants. On solving the integrals for `y` and
+ `z` and on substituting the resulting expressions into the first equation of the
+ system, we arrives at a first-order differential equations on `x`. Similarly doing
+ that for other two equations we will arrive at first order equation on `y` and `z`.
+
+ References
+ ==========
+ -https://eqworld.ipmnet.ru/en/solutions/sysode/sode0402.pdf
+
+ """
+ C1, C2 = get_numbered_constants(eq, num=2)
+ u, v, w = symbols('u, v, w')
+ p = Wild('p', exclude=[x(t), y(t), z(t), t])
+ q = Wild('q', exclude=[x(t), y(t), z(t), t])
+ s = Wild('s', exclude=[x(t), y(t), z(t), t])
+ f = Wild('f')
+ r1 = (diff(x(t),t) - eq[0]).match(y(t)*z(t)*f)
+ r = collect_const(r1[f]).match(p*f)
+ r.update(((diff(y(t),t) - eq[1])/r[f]).match(q*z(t)*x(t)))
+ r.update(((diff(z(t),t) - eq[2])/r[f]).match(s*x(t)*y(t)))
+ n1, d1 = r[p].as_numer_denom()
+ n2, d2 = r[q].as_numer_denom()
+ n3, d3 = r[s].as_numer_denom()
+ val = solve([n1*u-d1*v+d1*w, d2*u+n2*v-d2*w, -d3*u+d3*v+n3*w],[u,v])
+ vals = [val[v], val[u]]
+ c = lcm(vals[0].as_numer_denom()[1], vals[1].as_numer_denom()[1])
+ a = vals[0].subs(w, c)
+ b = vals[1].subs(w, c)
+ y_x = sqrt(((c*C1-C2) - a*(c-a)*x(t)**2)/(b*(c-b)))
+ z_x = sqrt(((b*C1-C2) - a*(b-a)*x(t)**2)/(c*(b-c)))
+ z_y = sqrt(((a*C1-C2) - b*(a-b)*y(t)**2)/(c*(a-c)))
+ x_y = sqrt(((c*C1-C2) - b*(c-b)*y(t)**2)/(a*(c-a)))
+ x_z = sqrt(((b*C1-C2) - c*(b-c)*z(t)**2)/(a*(b-a)))
+ y_z = sqrt(((a*C1-C2) - c*(a-c)*z(t)**2)/(b*(a-b)))
+ sol1 = dsolve(a*diff(x(t),t) - (b-c)*y_x*z_x*r[f])
+ sol2 = dsolve(b*diff(y(t),t) - (c-a)*z_y*x_y*r[f])
+ sol3 = dsolve(c*diff(z(t),t) - (a-b)*x_z*y_z*r[f])
+ return [sol1, sol2, sol3]
+
+def _nonlinear_3eq_order1_type3(x, y, z, t, eq):
+ r"""
+ Equations:
+
+ .. math:: x' = c F_2 - b F_3, \enspace y' = a F_3 - c F_1, \enspace z' = b F_1 - a F_2
+
+ where `F_n = F_n(x, y, z, t)`.
+
+ 1. First Integral:
+
+ .. math:: a x + b y + c z = C_1,
+
+ where C is an arbitrary constant.
+
+ 2. If we assume function `F_n` to be independent of `t`,i.e, `F_n` = `F_n (x, y, z)`
+ Then, on eliminating `t` and `z` from the first two equation of the system, one
+ arrives at the first-order equation
+
+ .. math:: \frac{dy}{dx} = \frac{a F_3 (x, y, z) - c F_1 (x, y, z)}{c F_2 (x, y, z) -
+ b F_3 (x, y, z)}
+
+ where `z = \frac{1}{c} (C_1 - a x - b y)`
+
+ References
+ ==========
+ -https://eqworld.ipmnet.ru/en/solutions/sysode/sode0404.pdf
+
+ """
+ C1 = get_numbered_constants(eq, num=1)
+ u, v, w = symbols('u, v, w')
+ fu, fv, fw = symbols('u, v, w', cls=Function)
+ p = Wild('p', exclude=[x(t), y(t), z(t), t])
+ q = Wild('q', exclude=[x(t), y(t), z(t), t])
+ s = Wild('s', exclude=[x(t), y(t), z(t), t])
+ F1, F2, F3 = symbols('F1, F2, F3', cls=Wild)
+ r1 = (diff(x(t), t) - eq[0]).match(F2-F3)
+ r = collect_const(r1[F2]).match(s*F2)
+ r.update(collect_const(r1[F3]).match(q*F3))
+ if eq[1].has(r[F2]) and not eq[1].has(r[F3]):
+ r[F2], r[F3] = r[F3], r[F2]
+ r[s], r[q] = -r[q], -r[s]
+ r.update((diff(y(t), t) - eq[1]).match(p*r[F3] - r[s]*F1))
+ a = r[p]; b = r[q]; c = r[s]
+ F1 = r[F1].subs(x(t), u).subs(y(t),v).subs(z(t), w)
+ F2 = r[F2].subs(x(t), u).subs(y(t),v).subs(z(t), w)
+ F3 = r[F3].subs(x(t), u).subs(y(t),v).subs(z(t), w)
+ z_xy = (C1-a*u-b*v)/c
+ y_zx = (C1-a*u-c*w)/b
+ x_yz = (C1-b*v-c*w)/a
+ y_x = dsolve(diff(fv(u),u) - ((a*F3-c*F1)/(c*F2-b*F3)).subs(w,z_xy).subs(v,fv(u))).rhs
+ z_x = dsolve(diff(fw(u),u) - ((b*F1-a*F2)/(c*F2-b*F3)).subs(v,y_zx).subs(w,fw(u))).rhs
+ z_y = dsolve(diff(fw(v),v) - ((b*F1-a*F2)/(a*F3-c*F1)).subs(u,x_yz).subs(w,fw(v))).rhs
+ x_y = dsolve(diff(fu(v),v) - ((c*F2-b*F3)/(a*F3-c*F1)).subs(w,z_xy).subs(u,fu(v))).rhs
+ y_z = dsolve(diff(fv(w),w) - ((a*F3-c*F1)/(b*F1-a*F2)).subs(u,x_yz).subs(v,fv(w))).rhs
+ x_z = dsolve(diff(fu(w),w) - ((c*F2-b*F3)/(b*F1-a*F2)).subs(v,y_zx).subs(u,fu(w))).rhs
+ sol1 = dsolve(diff(fu(t),t) - (c*F2 - b*F3).subs(v,y_x).subs(w,z_x).subs(u,fu(t))).rhs
+ sol2 = dsolve(diff(fv(t),t) - (a*F3 - c*F1).subs(u,x_y).subs(w,z_y).subs(v,fv(t))).rhs
+ sol3 = dsolve(diff(fw(t),t) - (b*F1 - a*F2).subs(u,x_z).subs(v,y_z).subs(w,fw(t))).rhs
+ return [sol1, sol2, sol3]
+
+def _nonlinear_3eq_order1_type4(x, y, z, t, eq):
+ r"""
+ Equations:
+
+ .. math:: x' = c z F_2 - b y F_3, \enspace y' = a x F_3 - c z F_1, \enspace z' = b y F_1 - a x F_2
+
+ where `F_n = F_n (x, y, z, t)`
+
+ 1. First integral:
+
+ .. math:: a x^{2} + b y^{2} + c z^{2} = C_1
+
+ where `C` is an arbitrary constant.
+
+ 2. Assuming the function `F_n` is independent of `t`: `F_n = F_n (x, y, z)`. Then on
+ eliminating `t` and `z` from the first two equations of the system, one arrives at
+ the first-order equation
+
+ .. math:: \frac{dy}{dx} = \frac{a x F_3 (x, y, z) - c z F_1 (x, y, z)}
+ {c z F_2 (x, y, z) - b y F_3 (x, y, z)}
+
+ where `z = \pm \sqrt{\frac{1}{c} (C_1 - a x^{2} - b y^{2})}`
+
+ References
+ ==========
+ -https://eqworld.ipmnet.ru/en/solutions/sysode/sode0405.pdf
+
+ """
+ C1 = get_numbered_constants(eq, num=1)
+ u, v, w = symbols('u, v, w')
+ p = Wild('p', exclude=[x(t), y(t), z(t), t])
+ q = Wild('q', exclude=[x(t), y(t), z(t), t])
+ s = Wild('s', exclude=[x(t), y(t), z(t), t])
+ F1, F2, F3 = symbols('F1, F2, F3', cls=Wild)
+ r1 = eq[0].match(diff(x(t),t) - z(t)*F2 + y(t)*F3)
+ r = collect_const(r1[F2]).match(s*F2)
+ r.update(collect_const(r1[F3]).match(q*F3))
+ if eq[1].has(r[F2]) and not eq[1].has(r[F3]):
+ r[F2], r[F3] = r[F3], r[F2]
+ r[s], r[q] = -r[q], -r[s]
+ r.update((diff(y(t),t) - eq[1]).match(p*x(t)*r[F3] - r[s]*z(t)*F1))
+ a = r[p]; b = r[q]; c = r[s]
+ F1 = r[F1].subs(x(t),u).subs(y(t),v).subs(z(t),w)
+ F2 = r[F2].subs(x(t),u).subs(y(t),v).subs(z(t),w)
+ F3 = r[F3].subs(x(t),u).subs(y(t),v).subs(z(t),w)
+ x_yz = sqrt((C1 - b*v**2 - c*w**2)/a)
+ y_zx = sqrt((C1 - c*w**2 - a*u**2)/b)
+ z_xy = sqrt((C1 - a*u**2 - b*v**2)/c)
+ y_x = dsolve(diff(v(u),u) - ((a*u*F3-c*w*F1)/(c*w*F2-b*v*F3)).subs(w,z_xy).subs(v,v(u))).rhs
+ z_x = dsolve(diff(w(u),u) - ((b*v*F1-a*u*F2)/(c*w*F2-b*v*F3)).subs(v,y_zx).subs(w,w(u))).rhs
+ z_y = dsolve(diff(w(v),v) - ((b*v*F1-a*u*F2)/(a*u*F3-c*w*F1)).subs(u,x_yz).subs(w,w(v))).rhs
+ x_y = dsolve(diff(u(v),v) - ((c*w*F2-b*v*F3)/(a*u*F3-c*w*F1)).subs(w,z_xy).subs(u,u(v))).rhs
+ y_z = dsolve(diff(v(w),w) - ((a*u*F3-c*w*F1)/(b*v*F1-a*u*F2)).subs(u,x_yz).subs(v,v(w))).rhs
+ x_z = dsolve(diff(u(w),w) - ((c*w*F2-b*v*F3)/(b*v*F1-a*u*F2)).subs(v,y_zx).subs(u,u(w))).rhs
+ sol1 = dsolve(diff(u(t),t) - (c*w*F2 - b*v*F3).subs(v,y_x).subs(w,z_x).subs(u,u(t))).rhs
+ sol2 = dsolve(diff(v(t),t) - (a*u*F3 - c*w*F1).subs(u,x_y).subs(w,z_y).subs(v,v(t))).rhs
+ sol3 = dsolve(diff(w(t),t) - (b*v*F1 - a*u*F2).subs(u,x_z).subs(v,y_z).subs(w,w(t))).rhs
+ return [sol1, sol2, sol3]
+
+def _nonlinear_3eq_order1_type5(x, y, z, t, eq):
+ r"""
+ .. math:: x' = x (c F_2 - b F_3), \enspace y' = y (a F_3 - c F_1), \enspace z' = z (b F_1 - a F_2)
+
+ where `F_n = F_n (x, y, z, t)` and are arbitrary functions.
+
+ First Integral:
+
+ .. math:: \left|x\right|^{a} \left|y\right|^{b} \left|z\right|^{c} = C_1
+
+ where `C` is an arbitrary constant. If the function `F_n` is independent of `t`,
+ then, by eliminating `t` and `z` from the first two equations of the system, one
+ arrives at a first-order equation.
+
+ References
+ ==========
+ -https://eqworld.ipmnet.ru/en/solutions/sysode/sode0406.pdf
+
+ """
+ C1 = get_numbered_constants(eq, num=1)
+ u, v, w = symbols('u, v, w')
+ fu, fv, fw = symbols('u, v, w', cls=Function)
+ p = Wild('p', exclude=[x(t), y(t), z(t), t])
+ q = Wild('q', exclude=[x(t), y(t), z(t), t])
+ s = Wild('s', exclude=[x(t), y(t), z(t), t])
+ F1, F2, F3 = symbols('F1, F2, F3', cls=Wild)
+ r1 = eq[0].match(diff(x(t), t) - x(t)*F2 + x(t)*F3)
+ r = collect_const(r1[F2]).match(s*F2)
+ r.update(collect_const(r1[F3]).match(q*F3))
+ if eq[1].has(r[F2]) and not eq[1].has(r[F3]):
+ r[F2], r[F3] = r[F3], r[F2]
+ r[s], r[q] = -r[q], -r[s]
+ r.update((diff(y(t), t) - eq[1]).match(y(t)*(p*r[F3] - r[s]*F1)))
+ a = r[p]; b = r[q]; c = r[s]
+ F1 = r[F1].subs(x(t), u).subs(y(t), v).subs(z(t), w)
+ F2 = r[F2].subs(x(t), u).subs(y(t), v).subs(z(t), w)
+ F3 = r[F3].subs(x(t), u).subs(y(t), v).subs(z(t), w)
+ x_yz = (C1*v**-b*w**-c)**-a
+ y_zx = (C1*w**-c*u**-a)**-b
+ z_xy = (C1*u**-a*v**-b)**-c
+ y_x = dsolve(diff(fv(u), u) - ((v*(a*F3 - c*F1))/(u*(c*F2 - b*F3))).subs(w, z_xy).subs(v, fv(u))).rhs
+ z_x = dsolve(diff(fw(u), u) - ((w*(b*F1 - a*F2))/(u*(c*F2 - b*F3))).subs(v, y_zx).subs(w, fw(u))).rhs
+ z_y = dsolve(diff(fw(v), v) - ((w*(b*F1 - a*F2))/(v*(a*F3 - c*F1))).subs(u, x_yz).subs(w, fw(v))).rhs
+ x_y = dsolve(diff(fu(v), v) - ((u*(c*F2 - b*F3))/(v*(a*F3 - c*F1))).subs(w, z_xy).subs(u, fu(v))).rhs
+ y_z = dsolve(diff(fv(w), w) - ((v*(a*F3 - c*F1))/(w*(b*F1 - a*F2))).subs(u, x_yz).subs(v, fv(w))).rhs
+ x_z = dsolve(diff(fu(w), w) - ((u*(c*F2 - b*F3))/(w*(b*F1 - a*F2))).subs(v, y_zx).subs(u, fu(w))).rhs
+ sol1 = dsolve(diff(fu(t), t) - (u*(c*F2 - b*F3)).subs(v, y_x).subs(w, z_x).subs(u, fu(t))).rhs
+ sol2 = dsolve(diff(fv(t), t) - (v*(a*F3 - c*F1)).subs(u, x_y).subs(w, z_y).subs(v, fv(t))).rhs
+ sol3 = dsolve(diff(fw(t), t) - (w*(b*F1 - a*F2)).subs(u, x_z).subs(v, y_z).subs(w, fw(t))).rhs
+ return [sol1, sol2, sol3]
+
+
+#This import is written at the bottom to avoid circular imports.
+from .single import SingleODEProblem, SingleODESolver, solver_map
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/riccati.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/riccati.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc59bf17b91d75f621c89c64497846bd4fe8c2be
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/riccati.py
@@ -0,0 +1,893 @@
+r"""
+This module contains :py:meth:`~sympy.solvers.ode.riccati.solve_riccati`,
+a function which gives all rational particular solutions to first order
+Riccati ODEs. A general first order Riccati ODE is given by -
+
+.. math:: y' = b_0(x) + b_1(x)w + b_2(x)w^2
+
+where `b_0, b_1` and `b_2` can be arbitrary rational functions of `x`
+with `b_2 \ne 0`. When `b_2 = 0`, the equation is not a Riccati ODE
+anymore and becomes a Linear ODE. Similarly, when `b_0 = 0`, the equation
+is a Bernoulli ODE. The algorithm presented below can find rational
+solution(s) to all ODEs with `b_2 \ne 0` that have a rational solution,
+or prove that no rational solution exists for the equation.
+
+Background
+==========
+
+A Riccati equation can be transformed to its normal form
+
+.. math:: y' + y^2 = a(x)
+
+using the transformation
+
+.. math:: y = -b_2(x) - \frac{b'_2(x)}{2 b_2(x)} - \frac{b_1(x)}{2}
+
+where `a(x)` is given by
+
+.. math:: a(x) = \frac{1}{4}\left(\frac{b_2'}{b_2} + b_1\right)^2 - \frac{1}{2}\left(\frac{b_2'}{b_2} + b_1\right)' - b_0 b_2
+
+Thus, we can develop an algorithm to solve for the Riccati equation
+in its normal form, which would in turn give us the solution for
+the original Riccati equation.
+
+Algorithm
+=========
+
+The algorithm implemented here is presented in the Ph.D thesis
+"Rational and Algebraic Solutions of First-Order Algebraic ODEs"
+by N. Thieu Vo. The entire thesis can be found here -
+https://www3.risc.jku.at/publications/download/risc_5387/PhDThesisThieu.pdf
+
+We have only implemented the Rational Riccati solver (Algorithm 11,
+Pg 78-82 in Thesis). Before we proceed towards the implementation
+of the algorithm, a few definitions to understand are -
+
+1. Valuation of a Rational Function at `\infty`:
+ The valuation of a rational function `p(x)` at `\infty` is equal
+ to the difference between the degree of the denominator and the
+ numerator of `p(x)`.
+
+ NOTE: A general definition of valuation of a rational function
+ at any value of `x` can be found in Pg 63 of the thesis, but
+ is not of any interest for this algorithm.
+
+2. Zeros and Poles of a Rational Function:
+ Let `a(x) = \frac{S(x)}{T(x)}, T \ne 0` be a rational function
+ of `x`. Then -
+
+ a. The Zeros of `a(x)` are the roots of `S(x)`.
+ b. The Poles of `a(x)` are the roots of `T(x)`. However, `\infty`
+ can also be a pole of a(x). We say that `a(x)` has a pole at
+ `\infty` if `a(\frac{1}{x})` has a pole at 0.
+
+Every pole is associated with an order that is equal to the multiplicity
+of its appearance as a root of `T(x)`. A pole is called a simple pole if
+it has an order 1. Similarly, a pole is called a multiple pole if it has
+an order `\ge` 2.
+
+Necessary Conditions
+====================
+
+For a Riccati equation in its normal form,
+
+.. math:: y' + y^2 = a(x)
+
+we can define
+
+a. A pole is called a movable pole if it is a pole of `y(x)` and is not
+a pole of `a(x)`.
+b. Similarly, a pole is called a non-movable pole if it is a pole of both
+`y(x)` and `a(x)`.
+
+Then, the algorithm states that a rational solution exists only if -
+
+a. Every pole of `a(x)` must be either a simple pole or a multiple pole
+of even order.
+b. The valuation of `a(x)` at `\infty` must be even or be `\ge` 2.
+
+This algorithm finds all possible rational solutions for the Riccati ODE.
+If no rational solutions are found, it means that no rational solutions
+exist.
+
+The algorithm works for Riccati ODEs where the coefficients are rational
+functions in the independent variable `x` with rational number coefficients
+i.e. in `Q(x)`. The coefficients in the rational function cannot be floats,
+irrational numbers, symbols or any other kind of expression. The reasons
+for this are -
+
+1. When using symbols, different symbols could take the same value and this
+would affect the multiplicity of poles if symbols are present here.
+
+2. An integer degree bound is required to calculate a polynomial solution
+to an auxiliary differential equation, which in turn gives the particular
+solution for the original ODE. If symbols/floats/irrational numbers are
+present, we cannot determine if the expression for the degree bound is an
+integer or not.
+
+Solution
+========
+
+With these definitions, we can state a general form for the solution of
+the equation. `y(x)` must have the form -
+
+.. math:: y(x) = \sum_{i=1}^{n} \sum_{j=1}^{r_i} \frac{c_{ij}}{(x - x_i)^j} + \sum_{i=1}^{m} \frac{1}{x - \chi_i} + \sum_{i=0}^{N} d_i x^i
+
+where `x_1, x_2, \dots, x_n` are non-movable poles of `a(x)`,
+`\chi_1, \chi_2, \dots, \chi_m` are movable poles of `a(x)`, and the values
+of `N, n, r_1, r_2, \dots, r_n` can be determined from `a(x)`. The
+coefficient vectors `(d_0, d_1, \dots, d_N)` and `(c_{i1}, c_{i2}, \dots, c_{i r_i})`
+can be determined from `a(x)`. We will have 2 choices each of these vectors
+and part of the procedure is figuring out which of the 2 should be used
+to get the solution correctly.
+
+Implementation
+==============
+
+In this implementation, we use ``Poly`` to represent a rational function
+rather than using ``Expr`` since ``Poly`` is much faster. Since we cannot
+represent rational functions directly using ``Poly``, we instead represent
+a rational function with 2 ``Poly`` objects - one for its numerator and
+the other for its denominator.
+
+The code is written to match the steps given in the thesis (Pg 82)
+
+Step 0 : Match the equation -
+Find `b_0, b_1` and `b_2`. If `b_2 = 0` or no such functions exist, raise
+an error
+
+Step 1 : Transform the equation to its normal form as explained in the
+theory section.
+
+Step 2 : Initialize an empty set of solutions, ``sol``.
+
+Step 3 : If `a(x) = 0`, append `\frac{1}/{(x - C1)}` to ``sol``.
+
+Step 4 : If `a(x)` is a rational non-zero number, append `\pm \sqrt{a}`
+to ``sol``.
+
+Step 5 : Find the poles and their multiplicities of `a(x)`. Let
+the number of poles be `n`. Also find the valuation of `a(x)` at
+`\infty` using ``val_at_inf``.
+
+NOTE: Although the algorithm considers `\infty` as a pole, it is
+not mentioned if it a part of the set of finite poles. `\infty`
+is NOT a part of the set of finite poles. If a pole exists at
+`\infty`, we use its multiplicity to find the laurent series of
+`a(x)` about `\infty`.
+
+Step 6 : Find `n` c-vectors (one for each pole) and 1 d-vector using
+``construct_c`` and ``construct_d``. Now, determine all the ``2**(n + 1)``
+combinations of choosing between 2 choices for each of the `n` c-vectors
+and 1 d-vector.
+
+NOTE: The equation for `d_{-1}` in Case 4 (Pg 80) has a printinig
+mistake. The term `- d_N` must be replaced with `-N d_N`. The same
+has been explained in the code as well.
+
+For each of these above combinations, do
+
+Step 8 : Compute `m` in ``compute_m_ybar``. `m` is the degree bound of
+the polynomial solution we must find for the auxiliary equation.
+
+Step 9 : In ``compute_m_ybar``, compute ybar as well where ``ybar`` is
+one part of y(x) -
+
+.. math:: \overline{y}(x) = \sum_{i=1}^{n} \sum_{j=1}^{r_i} \frac{c_{ij}}{(x - x_i)^j} + \sum_{i=0}^{N} d_i x^i
+
+Step 10 : If `m` is a non-negative integer -
+
+Step 11: Find a polynomial solution of degree `m` for the auxiliary equation.
+
+There are 2 cases possible -
+
+ a. `m` is a non-negative integer: We can solve for the coefficients
+ in `p(x)` using Undetermined Coefficients.
+
+ b. `m` is not a non-negative integer: In this case, we cannot find
+ a polynomial solution to the auxiliary equation, and hence, we ignore
+ this value of `m`.
+
+Step 12 : For each `p(x)` that exists, append `ybar + \frac{p'(x)}{p(x)}`
+to ``sol``.
+
+Step 13 : For each solution in ``sol``, apply an inverse transformation,
+so that the solutions of the original equation are found using the
+solutions of the equation in its normal form.
+"""
+
+
+from itertools import product
+from sympy.core import S
+from sympy.core.add import Add
+from sympy.core.numbers import oo, Float
+from sympy.core.function import count_ops
+from sympy.core.relational import Eq
+from sympy.core.symbol import symbols, Symbol, Dummy
+from sympy.functions import sqrt, exp
+from sympy.functions.elementary.complexes import sign
+from sympy.integrals.integrals import Integral
+from sympy.polys.domains import ZZ
+from sympy.polys.polytools import Poly
+from sympy.polys.polyroots import roots
+from sympy.solvers.solveset import linsolve
+
+
+def riccati_normal(w, x, b1, b2):
+ """
+ Given a solution `w(x)` to the equation
+
+ .. math:: w'(x) = b_0(x) + b_1(x)*w(x) + b_2(x)*w(x)^2
+
+ and rational function coefficients `b_1(x)` and
+ `b_2(x)`, this function transforms the solution to
+ give a solution `y(x)` for its corresponding normal
+ Riccati ODE
+
+ .. math:: y'(x) + y(x)^2 = a(x)
+
+ using the transformation
+
+ .. math:: y(x) = -b_2(x)*w(x) - b'_2(x)/(2*b_2(x)) - b_1(x)/2
+ """
+ return -b2*w - b2.diff(x)/(2*b2) - b1/2
+
+
+def riccati_inverse_normal(y, x, b1, b2, bp=None):
+ """
+ Inverse transforming the solution to the normal
+ Riccati ODE to get the solution to the Riccati ODE.
+ """
+ # bp is the expression which is independent of the solution
+ # and hence, it need not be computed again
+ if bp is None:
+ bp = -b2.diff(x)/(2*b2**2) - b1/(2*b2)
+ # w(x) = -y(x)/b2(x) - b2'(x)/(2*b2(x)^2) - b1(x)/(2*b2(x))
+ return -y/b2 + bp
+
+
+def riccati_reduced(eq, f, x):
+ """
+ Convert a Riccati ODE into its corresponding
+ normal Riccati ODE.
+ """
+ match, funcs = match_riccati(eq, f, x)
+ # If equation is not a Riccati ODE, exit
+ if not match:
+ return False
+ # Using the rational functions, find the expression for a(x)
+ b0, b1, b2 = funcs
+ a = -b0*b2 + b1**2/4 - b1.diff(x)/2 + 3*b2.diff(x)**2/(4*b2**2) + b1*b2.diff(x)/(2*b2) - \
+ b2.diff(x, 2)/(2*b2)
+ # Normal form of Riccati ODE is f'(x) + f(x)^2 = a(x)
+ return f(x).diff(x) + f(x)**2 - a
+
+def linsolve_dict(eq, syms):
+ """
+ Get the output of linsolve as a dict
+ """
+ # Convert tuple type return value of linsolve
+ # to a dictionary for ease of use
+ sol = linsolve(eq, syms)
+ if not sol:
+ return {}
+ return {k:v for k, v in zip(syms, list(sol)[0])}
+
+
+def match_riccati(eq, f, x):
+ """
+ A function that matches and returns the coefficients
+ if an equation is a Riccati ODE
+
+ Parameters
+ ==========
+
+ eq: Equation to be matched
+ f: Dependent variable
+ x: Independent variable
+
+ Returns
+ =======
+
+ match: True if equation is a Riccati ODE, False otherwise
+ funcs: [b0, b1, b2] if match is True, [] otherwise. Here,
+ b0, b1 and b2 are rational functions which match the equation.
+ """
+ # Group terms based on f(x)
+ if isinstance(eq, Eq):
+ eq = eq.lhs - eq.rhs
+ eq = eq.expand().collect(f(x))
+ cf = eq.coeff(f(x).diff(x))
+
+ # There must be an f(x).diff(x) term.
+ # eq must be an Add object since we are using the expanded
+ # equation and it must have atleast 2 terms (b2 != 0)
+ if cf != 0 and isinstance(eq, Add):
+
+ # Divide all coefficients by the coefficient of f(x).diff(x)
+ # and add the terms again to get the same equation
+ eq = Add(*((x/cf).cancel() for x in eq.args)).collect(f(x))
+
+ # Match the equation with the pattern
+ b1 = -eq.coeff(f(x))
+ b2 = -eq.coeff(f(x)**2)
+ b0 = (f(x).diff(x) - b1*f(x) - b2*f(x)**2 - eq).expand()
+ funcs = [b0, b1, b2]
+
+ # Check if coefficients are not symbols and floats
+ if any(len(x.atoms(Symbol)) > 1 or len(x.atoms(Float)) for x in funcs):
+ return False, []
+
+ # If b_0(x) contains f(x), it is not a Riccati ODE
+ if len(b0.atoms(f)) or not all((b2 != 0, b0.is_rational_function(x),
+ b1.is_rational_function(x), b2.is_rational_function(x))):
+ return False, []
+ return True, funcs
+ return False, []
+
+
+def val_at_inf(num, den, x):
+ # Valuation of a rational function at oo = deg(denom) - deg(numer)
+ return den.degree(x) - num.degree(x)
+
+
+def check_necessary_conds(val_inf, muls):
+ """
+ The necessary conditions for a rational solution
+ to exist are as follows -
+
+ i) Every pole of a(x) must be either a simple pole
+ or a multiple pole of even order.
+
+ ii) The valuation of a(x) at infinity must be even
+ or be greater than or equal to 2.
+
+ Here, a simple pole is a pole with multiplicity 1
+ and a multiple pole is a pole with multiplicity
+ greater than 1.
+ """
+ return (val_inf >= 2 or (val_inf <= 0 and val_inf%2 == 0)) and \
+ all(mul == 1 or (mul%2 == 0 and mul >= 2) for mul in muls)
+
+
+def inverse_transform_poly(num, den, x):
+ """
+ A function to make the substitution
+ x -> 1/x in a rational function that
+ is represented using Poly objects for
+ numerator and denominator.
+ """
+ # Declare for reuse
+ one = Poly(1, x)
+ xpoly = Poly(x, x)
+
+ # Check if degree of numerator is same as denominator
+ pwr = val_at_inf(num, den, x)
+ if pwr >= 0:
+ # Denominator has greater degree. Substituting x with
+ # 1/x would make the extra power go to the numerator
+ if num.expr != 0:
+ num = num.transform(one, xpoly) * x**pwr
+ den = den.transform(one, xpoly)
+ else:
+ # Numerator has greater degree. Substituting x with
+ # 1/x would make the extra power go to the denominator
+ num = num.transform(one, xpoly)
+ den = den.transform(one, xpoly) * x**(-pwr)
+ return num.cancel(den, include=True)
+
+
+def limit_at_inf(num, den, x):
+ """
+ Find the limit of a rational function
+ at oo
+ """
+ # pwr = degree(num) - degree(den)
+ pwr = -val_at_inf(num, den, x)
+ # Numerator has a greater degree than denominator
+ # Limit at infinity would depend on the sign of the
+ # leading coefficients of numerator and denominator
+ if pwr > 0:
+ return oo*sign(num.LC()/den.LC())
+ # Degree of numerator is equal to that of denominator
+ # Limit at infinity is just the ratio of leading coeffs
+ elif pwr == 0:
+ return num.LC()/den.LC()
+ # Degree of numerator is less than that of denominator
+ # Limit at infinity is just 0
+ else:
+ return 0
+
+
+def construct_c_case_1(num, den, x, pole):
+ # Find the coefficient of 1/(x - pole)**2 in the
+ # Laurent series expansion of a(x) about pole.
+ num1, den1 = (num*Poly((x - pole)**2, x, extension=True)).cancel(den, include=True)
+ r = (num1.subs(x, pole))/(den1.subs(x, pole))
+
+ # If multiplicity is 2, the coefficient to be added
+ # in the c-vector is c = (1 +- sqrt(1 + 4*r))/2
+ if r != -S(1)/4:
+ return [[(1 + sqrt(1 + 4*r))/2], [(1 - sqrt(1 + 4*r))/2]]
+ return [[S.Half]]
+
+
+def construct_c_case_2(num, den, x, pole, mul):
+ # Generate the coefficients using the recurrence
+ # relation mentioned in (5.14) in the thesis (Pg 80)
+
+ # r_i = mul/2
+ ri = mul//2
+
+ # Find the Laurent series coefficients about the pole
+ ser = rational_laurent_series(num, den, x, pole, mul, 6)
+
+ # Start with an empty memo to store the coefficients
+ # This is for the plus case
+ cplus = [0 for i in range(ri)]
+
+ # Base Case
+ cplus[ri-1] = sqrt(ser[2*ri])
+
+ # Iterate backwards to find all coefficients
+ s = ri - 1
+ sm = 0
+ for s in range(ri-1, 0, -1):
+ sm = 0
+ for j in range(s+1, ri):
+ sm += cplus[j-1]*cplus[ri+s-j-1]
+ if s!= 1:
+ cplus[s-1] = (ser[ri+s] - sm)/(2*cplus[ri-1])
+
+ # Memo for the minus case
+ cminus = [-x for x in cplus]
+
+ # Find the 0th coefficient in the recurrence
+ cplus[0] = (ser[ri+s] - sm - ri*cplus[ri-1])/(2*cplus[ri-1])
+ cminus[0] = (ser[ri+s] - sm - ri*cminus[ri-1])/(2*cminus[ri-1])
+
+ # Add both the plus and minus cases' coefficients
+ if cplus != cminus:
+ return [cplus, cminus]
+ return cplus
+
+
+def construct_c_case_3():
+ # If multiplicity is 1, the coefficient to be added
+ # in the c-vector is 1 (no choice)
+ return [[1]]
+
+
+def construct_c(num, den, x, poles, muls):
+ """
+ Helper function to calculate the coefficients
+ in the c-vector for each pole.
+ """
+ c = []
+ for pole, mul in zip(poles, muls):
+ c.append([])
+
+ # Case 3
+ if mul == 1:
+ # Add the coefficients from Case 3
+ c[-1].extend(construct_c_case_3())
+
+ # Case 1
+ elif mul == 2:
+ # Add the coefficients from Case 1
+ c[-1].extend(construct_c_case_1(num, den, x, pole))
+
+ # Case 2
+ else:
+ # Add the coefficients from Case 2
+ c[-1].extend(construct_c_case_2(num, den, x, pole, mul))
+
+ return c
+
+
+def construct_d_case_4(ser, N):
+ # Initialize an empty vector
+ dplus = [0 for i in range(N+2)]
+ # d_N = sqrt(a_{2*N})
+ dplus[N] = sqrt(ser[2*N])
+
+ # Use the recurrence relations to find
+ # the value of d_s
+ for s in range(N-1, -2, -1):
+ sm = 0
+ for j in range(s+1, N):
+ sm += dplus[j]*dplus[N+s-j]
+ if s != -1:
+ dplus[s] = (ser[N+s] - sm)/(2*dplus[N])
+
+ # Coefficients for the case of d_N = -sqrt(a_{2*N})
+ dminus = [-x for x in dplus]
+
+ # The third equation in Eq 5.15 of the thesis is WRONG!
+ # d_N must be replaced with N*d_N in that equation.
+ dplus[-1] = (ser[N+s] - N*dplus[N] - sm)/(2*dplus[N])
+ dminus[-1] = (ser[N+s] - N*dminus[N] - sm)/(2*dminus[N])
+
+ if dplus != dminus:
+ return [dplus, dminus]
+ return dplus
+
+
+def construct_d_case_5(ser):
+ # List to store coefficients for plus case
+ dplus = [0, 0]
+
+ # d_0 = sqrt(a_0)
+ dplus[0] = sqrt(ser[0])
+
+ # d_(-1) = a_(-1)/(2*d_0)
+ dplus[-1] = ser[-1]/(2*dplus[0])
+
+ # Coefficients for the minus case are just the negative
+ # of the coefficients for the positive case.
+ dminus = [-x for x in dplus]
+
+ if dplus != dminus:
+ return [dplus, dminus]
+ return dplus
+
+
+def construct_d_case_6(num, den, x):
+ # s_oo = lim x->0 1/x**2 * a(1/x) which is equivalent to
+ # s_oo = lim x->oo x**2 * a(x)
+ s_inf = limit_at_inf(Poly(x**2, x)*num, den, x)
+
+ # d_(-1) = (1 +- sqrt(1 + 4*s_oo))/2
+ if s_inf != -S(1)/4:
+ return [[(1 + sqrt(1 + 4*s_inf))/2], [(1 - sqrt(1 + 4*s_inf))/2]]
+ return [[S.Half]]
+
+
+def construct_d(num, den, x, val_inf):
+ """
+ Helper function to calculate the coefficients
+ in the d-vector based on the valuation of the
+ function at oo.
+ """
+ N = -val_inf//2
+ # Multiplicity of oo as a pole
+ mul = -val_inf if val_inf < 0 else 0
+ ser = rational_laurent_series(num, den, x, oo, mul, 1)
+
+ # Case 4
+ if val_inf < 0:
+ d = construct_d_case_4(ser, N)
+
+ # Case 5
+ elif val_inf == 0:
+ d = construct_d_case_5(ser)
+
+ # Case 6
+ else:
+ d = construct_d_case_6(num, den, x)
+
+ return d
+
+
+def rational_laurent_series(num, den, x, r, m, n):
+ r"""
+ The function computes the Laurent series coefficients
+ of a rational function.
+
+ Parameters
+ ==========
+
+ num: A Poly object that is the numerator of `f(x)`.
+ den: A Poly object that is the denominator of `f(x)`.
+ x: The variable of expansion of the series.
+ r: The point of expansion of the series.
+ m: Multiplicity of r if r is a pole of `f(x)`. Should
+ be zero otherwise.
+ n: Order of the term upto which the series is expanded.
+
+ Returns
+ =======
+
+ series: A dictionary that has power of the term as key
+ and coefficient of that term as value.
+
+ Below is a basic outline of how the Laurent series of a
+ rational function `f(x)` about `x_0` is being calculated -
+
+ 1. Substitute `x + x_0` in place of `x`. If `x_0`
+ is a pole of `f(x)`, multiply the expression by `x^m`
+ where `m` is the multiplicity of `x_0`. Denote the
+ the resulting expression as g(x). We do this substitution
+ so that we can now find the Laurent series of g(x) about
+ `x = 0`.
+
+ 2. We can then assume that the Laurent series of `g(x)`
+ takes the following form -
+
+ .. math:: g(x) = \frac{num(x)}{den(x)} = \sum_{m = 0}^{\infty} a_m x^m
+
+ where `a_m` denotes the Laurent series coefficients.
+
+ 3. Multiply the denominator to the RHS of the equation
+ and form a recurrence relation for the coefficients `a_m`.
+ """
+ one = Poly(1, x, extension=True)
+
+ if r == oo:
+ # Series at x = oo is equal to first transforming
+ # the function from x -> 1/x and finding the
+ # series at x = 0
+ num, den = inverse_transform_poly(num, den, x)
+ r = S(0)
+
+ if r:
+ # For an expansion about a non-zero point, a
+ # transformation from x -> x + r must be made
+ num = num.transform(Poly(x + r, x, extension=True), one)
+ den = den.transform(Poly(x + r, x, extension=True), one)
+
+ # Remove the pole from the denominator if the series
+ # expansion is about one of the poles
+ num, den = (num*x**m).cancel(den, include=True)
+
+ # Equate coefficients for the first terms (base case)
+ maxdegree = 1 + max(num.degree(), den.degree())
+ syms = symbols(f'a:{maxdegree}', cls=Dummy)
+ diff = num - den * Poly(syms[::-1], x)
+ coeff_diffs = diff.all_coeffs()[::-1][:maxdegree]
+ (coeffs, ) = linsolve(coeff_diffs, syms)
+
+ # Use the recursion relation for the rest
+ recursion = den.all_coeffs()[::-1]
+ div, rec_rhs = recursion[0], recursion[1:]
+ series = list(coeffs)
+ while len(series) < n:
+ next_coeff = Add(*(c*series[-1-n] for n, c in enumerate(rec_rhs))) / div
+ series.append(-next_coeff)
+ series = {m - i: val for i, val in enumerate(series)}
+ return series
+
+def compute_m_ybar(x, poles, choice, N):
+ """
+ Helper function to calculate -
+
+ 1. m - The degree bound for the polynomial
+ solution that must be found for the auxiliary
+ differential equation.
+
+ 2. ybar - Part of the solution which can be
+ computed using the poles, c and d vectors.
+ """
+ ybar = 0
+ m = Poly(choice[-1][-1], x, extension=True)
+
+ # Calculate the first (nested) summation for ybar
+ # as given in Step 9 of the Thesis (Pg 82)
+ dybar = []
+ for i, polei in enumerate(poles):
+ for j, cij in enumerate(choice[i]):
+ dybar.append(cij/(x - polei)**(j + 1))
+ m -=Poly(choice[i][0], x, extension=True) # can't accumulate Poly and use with Add
+ ybar += Add(*dybar)
+
+ # Calculate the second summation for ybar
+ for i in range(N+1):
+ ybar += choice[-1][i]*x**i
+ return (m.expr, ybar)
+
+
+def solve_aux_eq(numa, dena, numy, deny, x, m):
+ """
+ Helper function to find a polynomial solution
+ of degree m for the auxiliary differential
+ equation.
+ """
+ # Assume that the solution is of the type
+ # p(x) = C_0 + C_1*x + ... + C_{m-1}*x**(m-1) + x**m
+ psyms = symbols(f'C0:{m}', cls=Dummy)
+ K = ZZ[psyms]
+ psol = Poly(K.gens, x, domain=K) + Poly(x**m, x, domain=K)
+
+ # Eq (5.16) in Thesis - Pg 81
+ auxeq = (dena*(numy.diff(x)*deny - numy*deny.diff(x) + numy**2) - numa*deny**2)*psol
+ if m >= 1:
+ px = psol.diff(x)
+ auxeq += px*(2*numy*deny*dena)
+ if m >= 2:
+ auxeq += px.diff(x)*(deny**2*dena)
+ if m != 0:
+ # m is a non-zero integer. Find the constant terms using undetermined coefficients
+ return psol, linsolve_dict(auxeq.all_coeffs(), psyms), True
+ else:
+ # m == 0 . Check if 1 (x**0) is a solution to the auxiliary equation
+ return S.One, auxeq, auxeq == 0
+
+
+def remove_redundant_sols(sol1, sol2, x):
+ """
+ Helper function to remove redundant
+ solutions to the differential equation.
+ """
+ # If y1 and y2 are redundant solutions, there is
+ # some value of the arbitrary constant for which
+ # they will be equal
+
+ syms1 = sol1.atoms(Symbol, Dummy)
+ syms2 = sol2.atoms(Symbol, Dummy)
+ num1, den1 = [Poly(e, x, extension=True) for e in sol1.together().as_numer_denom()]
+ num2, den2 = [Poly(e, x, extension=True) for e in sol2.together().as_numer_denom()]
+ # Cross multiply
+ e = num1*den2 - den1*num2
+ # Check if there are any constants
+ syms = list(e.atoms(Symbol, Dummy))
+ if len(syms):
+ # Find values of constants for which solutions are equal
+ redn = linsolve(e.all_coeffs(), syms)
+ if len(redn):
+ # Return the general solution over a particular solution
+ if len(syms1) > len(syms2):
+ return sol2
+ # If both have constants, return the lesser complex solution
+ elif len(syms1) == len(syms2):
+ return sol1 if count_ops(syms1) >= count_ops(syms2) else sol2
+ else:
+ return sol1
+
+
+def get_gen_sol_from_part_sol(part_sols, a, x):
+ """"
+ Helper function which computes the general
+ solution for a Riccati ODE from its particular
+ solutions.
+
+ There are 3 cases to find the general solution
+ from the particular solutions for a Riccati ODE
+ depending on the number of particular solution(s)
+ we have - 1, 2 or 3.
+
+ For more information, see Section 6 of
+ "Methods of Solution of the Riccati Differential Equation"
+ by D. R. Haaheim and F. M. Stein
+ """
+
+ # If no particular solutions are found, a general
+ # solution cannot be found
+ if len(part_sols) == 0:
+ return []
+
+ # In case of a single particular solution, the general
+ # solution can be found by using the substitution
+ # y = y1 + 1/z and solving a Bernoulli ODE to find z.
+ elif len(part_sols) == 1:
+ y1 = part_sols[0]
+ i = exp(Integral(2*y1, x))
+ z = i * Integral(a/i, x)
+ z = z.doit()
+ if a == 0 or z == 0:
+ return y1
+ return y1 + 1/z
+
+ # In case of 2 particular solutions, the general solution
+ # can be found by solving a separable equation. This is
+ # the most common case, i.e. most Riccati ODEs have 2
+ # rational particular solutions.
+ elif len(part_sols) == 2:
+ y1, y2 = part_sols
+ # One of them already has a constant
+ if len(y1.atoms(Dummy)) + len(y2.atoms(Dummy)) > 0:
+ u = exp(Integral(y2 - y1, x)).doit()
+ # Introduce a constant
+ else:
+ C1 = Dummy('C1')
+ u = C1*exp(Integral(y2 - y1, x)).doit()
+ if u == 1:
+ return y2
+ return (y2*u - y1)/(u - 1)
+
+ # In case of 3 particular solutions, a closed form
+ # of the general solution can be obtained directly
+ else:
+ y1, y2, y3 = part_sols[:3]
+ C1 = Dummy('C1')
+ return (C1 + 1)*y2*(y1 - y3)/(C1*y1 + y2 - (C1 + 1)*y3)
+
+
+def solve_riccati(fx, x, b0, b1, b2, gensol=False):
+ """
+ The main function that gives particular/general
+ solutions to Riccati ODEs that have atleast 1
+ rational particular solution.
+ """
+ # Step 1 : Convert to Normal Form
+ a = -b0*b2 + b1**2/4 - b1.diff(x)/2 + 3*b2.diff(x)**2/(4*b2**2) + b1*b2.diff(x)/(2*b2) - \
+ b2.diff(x, 2)/(2*b2)
+ a_t = a.together()
+ num, den = [Poly(e, x, extension=True) for e in a_t.as_numer_denom()]
+ num, den = num.cancel(den, include=True)
+
+ # Step 2
+ presol = []
+
+ # Step 3 : a(x) is 0
+ if num == 0:
+ presol.append(1/(x + Dummy('C1')))
+
+ # Step 4 : a(x) is a non-zero constant
+ elif x not in num.free_symbols.union(den.free_symbols):
+ presol.extend([sqrt(a), -sqrt(a)])
+
+ # Step 5 : Find poles and valuation at infinity
+ poles = roots(den, x)
+ poles, muls = list(poles.keys()), list(poles.values())
+ val_inf = val_at_inf(num, den, x)
+
+ if len(poles):
+ # Check necessary conditions (outlined in the module docstring)
+ if not check_necessary_conds(val_inf, muls):
+ raise ValueError("Rational Solution doesn't exist")
+
+ # Step 6
+ # Construct c-vectors for each singular point
+ c = construct_c(num, den, x, poles, muls)
+
+ # Construct d vectors for each singular point
+ d = construct_d(num, den, x, val_inf)
+
+ # Step 7 : Iterate over all possible combinations and return solutions
+ # For each possible combination, generate an array of 0's and 1's
+ # where 0 means pick 1st choice and 1 means pick the second choice.
+
+ # NOTE: We could exit from the loop if we find 3 particular solutions,
+ # but it is not implemented here as -
+ # a. Finding 3 particular solutions is very rare. Most of the time,
+ # only 2 particular solutions are found.
+ # b. In case we exit after finding 3 particular solutions, it might
+ # happen that 1 or 2 of them are redundant solutions. So, instead of
+ # spending some more time in computing the particular solutions,
+ # we will end up computing the general solution from a single
+ # particular solution which is usually slower than computing the
+ # general solution from 2 or 3 particular solutions.
+ c.append(d)
+ choices = product(*c)
+ for choice in choices:
+ m, ybar = compute_m_ybar(x, poles, choice, -val_inf//2)
+ numy, deny = [Poly(e, x, extension=True) for e in ybar.together().as_numer_denom()]
+ # Step 10 : Check if a valid solution exists. If yes, also check
+ # if m is a non-negative integer
+ if m.is_nonnegative == True and m.is_integer == True:
+
+ # Step 11 : Find polynomial solutions of degree m for the auxiliary equation
+ psol, coeffs, exists = solve_aux_eq(num, den, numy, deny, x, m)
+
+ # Step 12 : If valid polynomial solution exists, append solution.
+ if exists:
+ # m == 0 case
+ if psol == 1 and coeffs == 0:
+ # p(x) = 1, so p'(x)/p(x) term need not be added
+ presol.append(ybar)
+ # m is a positive integer and there are valid coefficients
+ elif len(coeffs):
+ # Substitute the valid coefficients to get p(x)
+ psol = psol.xreplace(coeffs)
+ # y(x) = ybar(x) + p'(x)/p(x)
+ presol.append(ybar + psol.diff(x)/psol)
+
+ # Remove redundant solutions from the list of existing solutions
+ remove = set()
+ for i in range(len(presol)):
+ for j in range(i+1, len(presol)):
+ rem = remove_redundant_sols(presol[i], presol[j], x)
+ if rem is not None:
+ remove.add(rem)
+ sols = [x for x in presol if x not in remove]
+
+ # Step 15 : Inverse transform the solutions of the equation in normal form
+ bp = -b2.diff(x)/(2*b2**2) - b1/(2*b2)
+
+ # If general solution is required, compute it from the particular solutions
+ if gensol:
+ sols = [get_gen_sol_from_part_sol(sols, a, x)]
+
+ # Inverse transform the particular solutions
+ presol = [Eq(fx, riccati_inverse_normal(y, x, b1, b2, bp).cancel(extension=True)) for y in sols]
+ return presol
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/single.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/single.py
new file mode 100644
index 0000000000000000000000000000000000000000..8de89b37e580239f736dfda18b48143f9259b686
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/single.py
@@ -0,0 +1,2979 @@
+#
+# This is the module for ODE solver classes for single ODEs.
+#
+
+from __future__ import annotations
+from typing import ClassVar, Iterator
+
+from .riccati import match_riccati, solve_riccati
+from sympy.core import Add, S, Pow, Rational
+from sympy.core.cache import cached_property
+from sympy.core.exprtools import factor_terms
+from sympy.core.expr import Expr
+from sympy.core.function import AppliedUndef, Derivative, diff, Function, expand, Subs, _mexpand
+from sympy.core.numbers import zoo
+from sympy.core.relational import Equality, Eq
+from sympy.core.symbol import Symbol, Dummy, Wild
+from sympy.core.mul import Mul
+from sympy.functions import exp, tan, log, sqrt, besselj, bessely, cbrt, airyai, airybi
+from sympy.integrals import Integral
+from sympy.polys import Poly
+from sympy.polys.polytools import cancel, factor, degree
+from sympy.simplify import collect, simplify, separatevars, logcombine, posify # type: ignore
+from sympy.simplify.radsimp import fraction
+from sympy.utilities import numbered_symbols
+from sympy.solvers.solvers import solve
+from sympy.solvers.deutils import ode_order, _preprocess
+from sympy.polys.matrices.linsolve import _lin_eq2dict
+from sympy.polys.solvers import PolyNonlinearError
+from .hypergeometric import equivalence_hypergeometric, match_2nd_2F1_hypergeometric, \
+ get_sol_2F1_hypergeometric, match_2nd_hypergeometric
+from .nonhomogeneous import _get_euler_characteristic_eq_sols, _get_const_characteristic_eq_sols, \
+ _solve_undetermined_coefficients, _solve_variation_of_parameters, _test_term, _undetermined_coefficients_match, \
+ _get_simplified_sol
+from .lie_group import _ode_lie_group
+
+
+class ODEMatchError(NotImplementedError):
+ """Raised if a SingleODESolver is asked to solve an ODE it does not match"""
+ pass
+
+
+class SingleODEProblem:
+ """Represents an ordinary differential equation (ODE)
+
+ This class is used internally in the by dsolve and related
+ functions/classes so that properties of an ODE can be computed
+ efficiently.
+
+ Examples
+ ========
+
+ This class is used internally by dsolve. To instantiate an instance
+ directly first define an ODE problem:
+
+ >>> from sympy import Function, Symbol
+ >>> x = Symbol('x')
+ >>> f = Function('f')
+ >>> eq = f(x).diff(x, 2)
+
+ Now you can create a SingleODEProblem instance and query its properties:
+
+ >>> from sympy.solvers.ode.single import SingleODEProblem
+ >>> problem = SingleODEProblem(f(x).diff(x), f(x), x)
+ >>> problem.eq
+ Derivative(f(x), x)
+ >>> problem.func
+ f(x)
+ >>> problem.sym
+ x
+ """
+
+ # Instance attributes:
+ eq = None # type: Expr
+ func = None # type: AppliedUndef
+ sym = None # type: Symbol
+ _order = None # type: int
+ _eq_expanded = None # type: Expr
+ _eq_preprocessed = None # type: Expr
+ _eq_high_order_free = None
+
+ def __init__(self, eq, func, sym, prep=True, **kwargs):
+ assert isinstance(eq, Expr)
+ assert isinstance(func, AppliedUndef)
+ assert isinstance(sym, Symbol)
+ assert isinstance(prep, bool)
+ self.eq = eq
+ self.func = func
+ self.sym = sym
+ self.prep = prep
+ self.params = kwargs
+
+ @cached_property
+ def order(self) -> int:
+ return ode_order(self.eq, self.func)
+
+ @cached_property
+ def eq_preprocessed(self) -> Expr:
+ return self._get_eq_preprocessed()
+
+ @cached_property
+ def eq_high_order_free(self) -> Expr:
+ a = Wild('a', exclude=[self.func])
+ c1 = Wild('c1', exclude=[self.sym])
+ # Precondition to try remove f(x) from highest order derivative
+ reduced_eq = None
+ if self.eq.is_Add:
+ deriv_coef = self.eq.coeff(self.func.diff(self.sym, self.order))
+ if deriv_coef not in (1, 0):
+ r = deriv_coef.match(a*self.func**c1)
+ if r and r[c1]:
+ den = self.func**r[c1]
+ reduced_eq = Add(*[arg/den for arg in self.eq.args])
+ if not reduced_eq:
+ reduced_eq = expand(self.eq)
+ return reduced_eq
+
+ @cached_property
+ def eq_expanded(self) -> Expr:
+ return expand(self.eq_preprocessed)
+
+ def _get_eq_preprocessed(self) -> Expr:
+ if self.prep:
+ process_eq, process_func = _preprocess(self.eq, self.func)
+ if process_func != self.func:
+ raise ValueError
+ else:
+ process_eq = self.eq
+ return process_eq
+
+ def get_numbered_constants(self, num=1, start=1, prefix='C') -> list[Symbol]:
+ """
+ Returns a list of constants that do not occur
+ in eq already.
+ """
+ ncs = self.iter_numbered_constants(start, prefix)
+ Cs = [next(ncs) for i in range(num)]
+ return Cs
+
+ def iter_numbered_constants(self, start=1, prefix='C') -> Iterator[Symbol]:
+ """
+ Returns an iterator of constants that do not occur
+ in eq already.
+ """
+ atom_set = self.eq.free_symbols
+ func_set = self.eq.atoms(Function)
+ if func_set:
+ atom_set |= {Symbol(str(f.func)) for f in func_set}
+ return numbered_symbols(start=start, prefix=prefix, exclude=atom_set)
+
+ @cached_property
+ def is_autonomous(self):
+ u = Dummy('u')
+ x = self.sym
+ syms = self.eq.subs(self.func, u).free_symbols
+ return x not in syms
+
+ def get_linear_coefficients(self, eq, func, order):
+ r"""
+ Matches a differential equation to the linear form:
+
+ .. math:: a_n(x) y^{(n)} + \cdots + a_1(x)y' + a_0(x) y + B(x) = 0
+
+ Returns a dict of order:coeff terms, where order is the order of the
+ derivative on each term, and coeff is the coefficient of that derivative.
+ The key ``-1`` holds the function `B(x)`. Returns ``None`` if the ODE is
+ not linear. This function assumes that ``func`` has already been checked
+ to be good.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, cos, sin
+ >>> from sympy.abc import x
+ >>> from sympy.solvers.ode.single import SingleODEProblem
+ >>> f = Function('f')
+ >>> eq = f(x).diff(x, 3) + 2*f(x).diff(x) + \
+ ... x*f(x).diff(x, 2) + cos(x)*f(x).diff(x) + x - f(x) - \
+ ... sin(x)
+ >>> obj = SingleODEProblem(eq, f(x), x)
+ >>> obj.get_linear_coefficients(eq, f(x), 3)
+ {-1: x - sin(x), 0: -1, 1: cos(x) + 2, 2: x, 3: 1}
+ >>> eq = f(x).diff(x, 3) + 2*f(x).diff(x) + \
+ ... x*f(x).diff(x, 2) + cos(x)*f(x).diff(x) + x - f(x) - \
+ ... sin(f(x))
+ >>> obj = SingleODEProblem(eq, f(x), x)
+ >>> obj.get_linear_coefficients(eq, f(x), 3) == None
+ True
+
+ """
+ f = func.func
+ x = func.args[0]
+ symset = {Derivative(f(x), x, i) for i in range(order+1)}
+ try:
+ rhs, lhs_terms = _lin_eq2dict(eq, symset)
+ except PolyNonlinearError:
+ return None
+
+ if rhs.has(func) or any(c.has(func) for c in lhs_terms.values()):
+ return None
+ terms = {i: lhs_terms.get(f(x).diff(x, i), S.Zero) for i in range(order+1)}
+ terms[-1] = rhs
+ return terms
+
+ # TODO: Add methods that can be used by many ODE solvers:
+ # order
+ # is_linear()
+ # get_linear_coefficients()
+ # eq_prepared (the ODE in prepared form)
+
+
+class SingleODESolver:
+ """
+ Base class for Single ODE solvers.
+
+ Subclasses should implement the _matches and _get_general_solution
+ methods. This class is not intended to be instantiated directly but its
+ subclasses are as part of dsolve.
+
+ Examples
+ ========
+
+ You can use a subclass of SingleODEProblem to solve a particular type of
+ ODE. We first define a particular ODE problem:
+
+ >>> from sympy import Function, Symbol
+ >>> x = Symbol('x')
+ >>> f = Function('f')
+ >>> eq = f(x).diff(x, 2)
+
+ Now we solve this problem using the NthAlgebraic solver which is a
+ subclass of SingleODESolver:
+
+ >>> from sympy.solvers.ode.single import NthAlgebraic, SingleODEProblem
+ >>> problem = SingleODEProblem(eq, f(x), x)
+ >>> solver = NthAlgebraic(problem)
+ >>> solver.get_general_solution()
+ [Eq(f(x), _C*x + _C)]
+
+ The normal way to solve an ODE is to use dsolve (which would use
+ NthAlgebraic and other solvers internally). When using dsolve a number of
+ other things are done such as evaluating integrals, simplifying the
+ solution and renumbering the constants:
+
+ >>> from sympy import dsolve
+ >>> dsolve(eq, hint='nth_algebraic')
+ Eq(f(x), C1 + C2*x)
+ """
+
+ # Subclasses should store the hint name (the argument to dsolve) in this
+ # attribute
+ hint: ClassVar[str]
+
+ # Subclasses should define this to indicate if they support an _Integral
+ # hint.
+ has_integral: ClassVar[bool]
+
+ # The ODE to be solved
+ ode_problem = None # type: SingleODEProblem
+
+ # Cache whether or not the equation has matched the method
+ _matched: bool | None = None
+
+ # Subclasses should store in this attribute the list of order(s) of ODE
+ # that subclass can solve or leave it to None if not specific to any order
+ order: list | None = None
+
+ def __init__(self, ode_problem):
+ self.ode_problem = ode_problem
+
+ def matches(self) -> bool:
+ if self.order is not None and self.ode_problem.order not in self.order:
+ self._matched = False
+ return self._matched
+
+ if self._matched is None:
+ self._matched = self._matches()
+ return self._matched
+
+ def get_general_solution(self, *, simplify: bool = True) -> list[Equality]:
+ if not self.matches():
+ msg = "%s solver cannot solve:\n%s"
+ raise ODEMatchError(msg % (self.hint, self.ode_problem.eq))
+ return self._get_general_solution(simplify_flag=simplify)
+
+ def _matches(self) -> bool:
+ msg = "Subclasses of SingleODESolver should implement matches."
+ raise NotImplementedError(msg)
+
+ def _get_general_solution(self, *, simplify_flag: bool = True) -> list[Equality]:
+ msg = "Subclasses of SingleODESolver should implement get_general_solution."
+ raise NotImplementedError(msg)
+
+
+class SinglePatternODESolver(SingleODESolver):
+ '''Superclass for ODE solvers based on pattern matching'''
+
+ def wilds(self):
+ prob = self.ode_problem
+ f = prob.func.func
+ x = prob.sym
+ order = prob.order
+ return self._wilds(f, x, order)
+
+ def wilds_match(self):
+ match = self._wilds_match
+ return [match.get(w, S.Zero) for w in self.wilds()]
+
+ def _matches(self):
+ eq = self.ode_problem.eq_expanded
+ f = self.ode_problem.func.func
+ x = self.ode_problem.sym
+ order = self.ode_problem.order
+ df = f(x).diff(x, order)
+
+ if order not in [1, 2]:
+ return False
+
+ pattern = self._equation(f(x), x, order)
+
+ if not pattern.coeff(df).has(Wild):
+ eq = expand(eq / eq.coeff(df))
+ eq = eq.collect([f(x).diff(x), f(x)], func = cancel)
+
+ self._wilds_match = match = eq.match(pattern)
+ if match is not None:
+ return self._verify(f(x))
+ return False
+
+ def _verify(self, fx) -> bool:
+ return True
+
+ def _wilds(self, f, x, order):
+ msg = "Subclasses of SingleODESolver should implement _wilds"
+ raise NotImplementedError(msg)
+
+ def _equation(self, fx, x, order):
+ msg = "Subclasses of SingleODESolver should implement _equation"
+ raise NotImplementedError(msg)
+
+
+class NthAlgebraic(SingleODESolver):
+ r"""
+ Solves an `n`\th order ordinary differential equation using algebra and
+ integrals.
+
+ There is no general form for the kind of equation that this can solve. The
+ the equation is solved algebraically treating differentiation as an
+ invertible algebraic function.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, Eq
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> eq = Eq(f(x) * (f(x).diff(x)**2 - 1), 0)
+ >>> dsolve(eq, f(x), hint='nth_algebraic')
+ [Eq(f(x), 0), Eq(f(x), C1 - x), Eq(f(x), C1 + x)]
+
+ Note that this solver can return algebraic solutions that do not have any
+ integration constants (f(x) = 0 in the above example).
+ """
+
+ hint = 'nth_algebraic'
+ has_integral = True # nth_algebraic_Integral hint
+
+ def _matches(self):
+ r"""
+ Matches any differential equation that nth_algebraic can solve. Uses
+ `sympy.solve` but teaches it how to integrate derivatives.
+
+ This involves calling `sympy.solve` and does most of the work of finding a
+ solution (apart from evaluating the integrals).
+ """
+ eq = self.ode_problem.eq
+ func = self.ode_problem.func
+ var = self.ode_problem.sym
+
+ # Derivative that solve can handle:
+ diffx = self._get_diffx(var)
+
+ # Replace derivatives wrt the independent variable with diffx
+ def replace(eq, var):
+ def expand_diffx(*args):
+ differand, diffs = args[0], args[1:]
+ toreplace = differand
+ for v, n in diffs:
+ for _ in range(n):
+ if v == var:
+ toreplace = diffx(toreplace)
+ else:
+ toreplace = Derivative(toreplace, v)
+ return toreplace
+ return eq.replace(Derivative, expand_diffx)
+
+ # Restore derivatives in solution afterwards
+ def unreplace(eq, var):
+ return eq.replace(diffx, lambda e: Derivative(e, var))
+
+ subs_eqn = replace(eq, var)
+ try:
+ # turn off simplification to protect Integrals that have
+ # _t instead of fx in them and would otherwise factor
+ # as t_*Integral(1, x)
+ solns = solve(subs_eqn, func, simplify=False)
+ except NotImplementedError:
+ solns = []
+
+ solns = [simplify(unreplace(soln, var)) for soln in solns]
+ solns = [Equality(func, soln) for soln in solns]
+
+ self.solutions = solns
+ return len(solns) != 0
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ return self.solutions
+
+ # This needs to produce an invertible function but the inverse depends
+ # which variable we are integrating with respect to. Since the class can
+ # be stored in cached results we need to ensure that we always get the
+ # same class back for each particular integration variable so we store these
+ # classes in a global dict:
+ _diffx_stored: dict[Symbol, type[Function]] = {}
+
+ @staticmethod
+ def _get_diffx(var):
+ diffcls = NthAlgebraic._diffx_stored.get(var, None)
+
+ if diffcls is None:
+ # A class that behaves like Derivative wrt var but is "invertible".
+ class diffx(Function):
+ def inverse(self):
+ # don't use integrate here because fx has been replaced by _t
+ # in the equation; integrals will not be correct while solve
+ # is at work.
+ return lambda expr: Integral(expr, var) + Dummy('C')
+
+ diffcls = NthAlgebraic._diffx_stored.setdefault(var, diffx)
+
+ return diffcls
+
+
+class FirstExact(SinglePatternODESolver):
+ r"""
+ Solves 1st order exact ordinary differential equations.
+
+ A 1st order differential equation is called exact if it is the total
+ differential of a function. That is, the differential equation
+
+ .. math:: P(x, y) \,\partial{}x + Q(x, y) \,\partial{}y = 0
+
+ is exact if there is some function `F(x, y)` such that `P(x, y) =
+ \partial{}F/\partial{}x` and `Q(x, y) = \partial{}F/\partial{}y`. It can
+ be shown that a necessary and sufficient condition for a first order ODE
+ to be exact is that `\partial{}P/\partial{}y = \partial{}Q/\partial{}x`.
+ Then, the solution will be as given below::
+
+ >>> from sympy import Function, Eq, Integral, symbols, pprint
+ >>> x, y, t, x0, y0, C1= symbols('x,y,t,x0,y0,C1')
+ >>> P, Q, F= map(Function, ['P', 'Q', 'F'])
+ >>> pprint(Eq(Eq(F(x, y), Integral(P(t, y), (t, x0, x)) +
+ ... Integral(Q(x0, t), (t, y0, y))), C1))
+ x y
+ / /
+ | |
+ F(x, y) = | P(t, y) dt + | Q(x0, t) dt = C1
+ | |
+ / /
+ x0 y0
+
+ Where the first partials of `P` and `Q` exist and are continuous in a
+ simply connected region.
+
+ A note: SymPy currently has no way to represent inert substitution on an
+ expression, so the hint ``1st_exact_Integral`` will return an integral
+ with `dy`. This is supposed to represent the function that you are
+ solving for.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, cos, sin
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> dsolve(cos(f(x)) - (x*sin(f(x)) - f(x)**2)*f(x).diff(x),
+ ... f(x), hint='1st_exact')
+ Eq(x*cos(f(x)) + f(x)**3/3, C1)
+
+ References
+ ==========
+
+ - https://en.wikipedia.org/wiki/Exact_differential_equation
+ - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+ Dover 1963, pp. 73
+
+ # indirect doctest
+
+ """
+ hint = "1st_exact"
+ has_integral = True
+ order = [1]
+
+ def _wilds(self, f, x, order):
+ P = Wild('P', exclude=[f(x).diff(x)])
+ Q = Wild('Q', exclude=[f(x).diff(x)])
+ return P, Q
+
+ def _equation(self, fx, x, order):
+ P, Q = self.wilds()
+ return P + Q*fx.diff(x)
+
+ def _verify(self, fx) -> bool:
+ P, Q = self.wilds()
+ x = self.ode_problem.sym
+ y = Dummy('y')
+
+ m, n = self.wilds_match()
+
+ m = m.subs(fx, y)
+ n = n.subs(fx, y)
+ numerator = cancel(m.diff(y) - n.diff(x))
+
+ if numerator.is_zero:
+ # Is exact
+ return True
+ else:
+ # The following few conditions try to convert a non-exact
+ # differential equation into an exact one.
+ # References:
+ # 1. Differential equations with applications
+ # and historical notes - George E. Simmons
+ # 2. https://math.okstate.edu/people/binegar/2233-S99/2233-l12.pdf
+
+ factor_n = cancel(numerator/n)
+ factor_m = cancel(-numerator/m)
+ if y not in factor_n.free_symbols:
+ # If (dP/dy - dQ/dx) / Q = f(x)
+ # then exp(integral(f(x))*equation becomes exact
+ factor = factor_n
+ integration_variable = x
+ elif x not in factor_m.free_symbols:
+ # If (dP/dy - dQ/dx) / -P = f(y)
+ # then exp(integral(f(y))*equation becomes exact
+ factor = factor_m
+ integration_variable = y
+ else:
+ # Couldn't convert to exact
+ return False
+
+ factor = exp(Integral(factor, integration_variable))
+ m *= factor
+ n *= factor
+ self._wilds_match[P] = m.subs(y, fx)
+ self._wilds_match[Q] = n.subs(y, fx)
+ return True
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ m, n = self.wilds_match()
+ fx = self.ode_problem.func
+ x = self.ode_problem.sym
+ (C1,) = self.ode_problem.get_numbered_constants(num=1)
+ y = Dummy('y')
+
+ m = m.subs(fx, y)
+ n = n.subs(fx, y)
+
+ gen_sol = Eq(Subs(Integral(m, x)
+ + Integral(n - Integral(m, x).diff(y), y), y, fx), C1)
+ return [gen_sol]
+
+
+class FirstLinear(SinglePatternODESolver):
+ r"""
+ Solves 1st order linear differential equations.
+
+ These are differential equations of the form
+
+ .. math:: dy/dx + P(x) y = Q(x)\text{.}
+
+ These kinds of differential equations can be solved in a general way. The
+ integrating factor `e^{\int P(x) \,dx}` will turn the equation into a
+ separable equation. The general solution is::
+
+ >>> from sympy import Function, dsolve, Eq, pprint, diff, sin
+ >>> from sympy.abc import x
+ >>> f, P, Q = map(Function, ['f', 'P', 'Q'])
+ >>> genform = Eq(f(x).diff(x) + P(x)*f(x), Q(x))
+ >>> pprint(genform)
+ d
+ P(x)*f(x) + --(f(x)) = Q(x)
+ dx
+ >>> pprint(dsolve(genform, f(x), hint='1st_linear_Integral'))
+ / / \
+ | | |
+ | | / | /
+ | | | | |
+ | | | P(x) dx | - | P(x) dx
+ | | | | |
+ | | / | /
+ f(x) = |C1 + | Q(x)*e dx|*e
+ | | |
+ \ / /
+
+
+ Examples
+ ========
+
+ >>> f = Function('f')
+ >>> pprint(dsolve(Eq(x*diff(f(x), x) - f(x), x**2*sin(x)),
+ ... f(x), '1st_linear'))
+ f(x) = x*(C1 - cos(x))
+
+ References
+ ==========
+
+ - https://en.wikipedia.org/wiki/Linear_differential_equation#First-order_equation_with_variable_coefficients
+ - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+ Dover 1963, pp. 92
+
+ # indirect doctest
+
+ """
+ hint = '1st_linear'
+ has_integral = True
+ order = [1]
+
+ def _wilds(self, f, x, order):
+ P = Wild('P', exclude=[f(x)])
+ Q = Wild('Q', exclude=[f(x), f(x).diff(x)])
+ return P, Q
+
+ def _equation(self, fx, x, order):
+ P, Q = self.wilds()
+ return fx.diff(x) + P*fx - Q
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ P, Q = self.wilds_match()
+ fx = self.ode_problem.func
+ x = self.ode_problem.sym
+ (C1,) = self.ode_problem.get_numbered_constants(num=1)
+ gensol = Eq(fx, ((C1 + Integral(Q*exp(Integral(P, x)), x))
+ * exp(-Integral(P, x))))
+ return [gensol]
+
+
+class AlmostLinear(SinglePatternODESolver):
+ r"""
+ Solves an almost-linear differential equation.
+
+ The general form of an almost linear differential equation is
+
+ .. math:: a(x) g'(f(x)) f'(x) + b(x) g(f(x)) + c(x)
+
+ Here `f(x)` is the function to be solved for (the dependent variable).
+ The substitution `g(f(x)) = u(x)` leads to a linear differential equation
+ for `u(x)` of the form `a(x) u' + b(x) u + c(x) = 0`. This can be solved
+ for `u(x)` by the `first_linear` hint and then `f(x)` is found by solving
+ `g(f(x)) = u(x)`.
+
+ See Also
+ ========
+ :obj:`sympy.solvers.ode.single.FirstLinear`
+
+ Examples
+ ========
+
+ >>> from sympy import dsolve, Function, pprint, sin, cos
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> d = f(x).diff(x)
+ >>> eq = x*d + x*f(x) + 1
+ >>> dsolve(eq, f(x), hint='almost_linear')
+ Eq(f(x), (C1 - Ei(x))*exp(-x))
+ >>> pprint(dsolve(eq, f(x), hint='almost_linear'))
+ -x
+ f(x) = (C1 - Ei(x))*e
+ >>> example = cos(f(x))*f(x).diff(x) + sin(f(x)) + 1
+ >>> pprint(example)
+ d
+ sin(f(x)) + cos(f(x))*--(f(x)) + 1
+ dx
+ >>> pprint(dsolve(example, f(x), hint='almost_linear'))
+ / -x \ / -x \
+ [f(x) = pi - asin\C1*e - 1/, f(x) = asin\C1*e - 1/]
+
+
+ References
+ ==========
+
+ - Joel Moses, "Symbolic Integration - The Stormy Decade", Communications
+ of the ACM, Volume 14, Number 8, August 1971, pp. 558
+ """
+ hint = "almost_linear"
+ has_integral = True
+ order = [1]
+
+ def _wilds(self, f, x, order):
+ P = Wild('P', exclude=[f(x).diff(x)])
+ Q = Wild('Q', exclude=[f(x).diff(x)])
+ return P, Q
+
+ def _equation(self, fx, x, order):
+ P, Q = self.wilds()
+ return P*fx.diff(x) + Q
+
+ def _verify(self, fx):
+ a, b = self.wilds_match()
+ c, b = b.as_independent(fx) if b.is_Add else (S.Zero, b)
+ # a, b and c are the function a(x), b(x) and c(x) respectively.
+ # c(x) is obtained by separating out b as terms with and without fx i.e, l(y)
+ # The following conditions checks if the given equation is an almost-linear differential equation using the fact that
+ # a(x)*(l(y))' / l(y)' is independent of l(y)
+
+ if b.diff(fx) != 0 and not simplify(b.diff(fx)/a).has(fx):
+ self.ly = factor_terms(b).as_independent(fx, as_Add=False)[1] # Gives the term containing fx i.e., l(y)
+ self.ax = a / self.ly.diff(fx)
+ self.cx = -c # cx is taken as -c(x) to simplify expression in the solution integral
+ self.bx = factor_terms(b) / self.ly
+ return True
+
+ return False
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ x = self.ode_problem.sym
+ (C1,) = self.ode_problem.get_numbered_constants(num=1)
+ gensol = Eq(self.ly, ((C1 + Integral((self.cx/self.ax)*exp(Integral(self.bx/self.ax, x)), x))
+ * exp(-Integral(self.bx/self.ax, x))))
+
+ return [gensol]
+
+
+class Bernoulli(SinglePatternODESolver):
+ r"""
+ Solves Bernoulli differential equations.
+
+ These are equations of the form
+
+ .. math:: dy/dx + P(x) y = Q(x) y^n\text{, }n \ne 1`\text{.}
+
+ The substitution `w = 1/y^{1-n}` will transform an equation of this form
+ into one that is linear (see the docstring of
+ :obj:`~sympy.solvers.ode.single.FirstLinear`). The general solution is::
+
+ >>> from sympy import Function, dsolve, Eq, pprint
+ >>> from sympy.abc import x, n
+ >>> f, P, Q = map(Function, ['f', 'P', 'Q'])
+ >>> genform = Eq(f(x).diff(x) + P(x)*f(x), Q(x)*f(x)**n)
+ >>> pprint(genform)
+ d n
+ P(x)*f(x) + --(f(x)) = Q(x)*f (x)
+ dx
+ >>> pprint(dsolve(genform, f(x), hint='Bernoulli_Integral'), num_columns=110)
+ -1
+ -----
+ n - 1
+ // / / \ \
+ || | | | |
+ || | / | / | / |
+ || | | | | | | |
+ || | -(n - 1)* | P(x) dx | -(n - 1)* | P(x) dx | (n - 1)* | P(x) dx|
+ || | | | | | | |
+ || | / | / | / |
+ f(x) = ||C1 - n* | Q(x)*e dx + | Q(x)*e dx|*e |
+ || | | | |
+ \\ / / / /
+
+
+ Note that the equation is separable when `n = 1` (see the docstring of
+ :obj:`~sympy.solvers.ode.single.Separable`).
+
+ >>> pprint(dsolve(Eq(f(x).diff(x) + P(x)*f(x), Q(x)*f(x)), f(x),
+ ... hint='separable_Integral'))
+ f(x)
+ /
+ | /
+ | 1 |
+ | - dy = C1 + | (-P(x) + Q(x)) dx
+ | y |
+ | /
+ /
+
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, Eq, pprint, log
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+
+ >>> pprint(dsolve(Eq(x*f(x).diff(x) + f(x), log(x)*f(x)**2),
+ ... f(x), hint='Bernoulli'))
+ 1
+ f(x) = -----------------
+ C1*x + log(x) + 1
+
+ References
+ ==========
+
+ - https://en.wikipedia.org/wiki/Bernoulli_differential_equation
+
+ - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+ Dover 1963, pp. 95
+
+ # indirect doctest
+
+ """
+ hint = "Bernoulli"
+ has_integral = True
+ order = [1]
+
+ def _wilds(self, f, x, order):
+ P = Wild('P', exclude=[f(x)])
+ Q = Wild('Q', exclude=[f(x)])
+ n = Wild('n', exclude=[x, f(x), f(x).diff(x)])
+ return P, Q, n
+
+ def _equation(self, fx, x, order):
+ P, Q, n = self.wilds()
+ return fx.diff(x) + P*fx - Q*fx**n
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ P, Q, n = self.wilds_match()
+ fx = self.ode_problem.func
+ x = self.ode_problem.sym
+ (C1,) = self.ode_problem.get_numbered_constants(num=1)
+ if n==1:
+ gensol = Eq(log(fx), (
+ C1 + Integral((-P + Q), x)
+ ))
+ else:
+ gensol = Eq(fx**(1-n), (
+ (C1 - (n - 1) * Integral(Q*exp(-n*Integral(P, x))
+ * exp(Integral(P, x)), x)
+ ) * exp(-(1 - n)*Integral(P, x)))
+ )
+ return [gensol]
+
+
+class Factorable(SingleODESolver):
+ r"""
+ Solves equations having a solvable factor.
+
+ This function is used to solve the equation having factors. Factors may be of type algebraic or ode. It
+ will try to solve each factor independently. Factors will be solved by calling dsolve. We will return the
+ list of solutions.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, pprint
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> eq = (f(x)**2-4)*(f(x).diff(x)+f(x))
+ >>> pprint(dsolve(eq, f(x)))
+ -x
+ [f(x) = 2, f(x) = -2, f(x) = C1*e ]
+
+
+ """
+ hint = "factorable"
+ has_integral = False
+
+ def _matches(self):
+ eq_orig = self.ode_problem.eq
+ f = self.ode_problem.func.func
+ x = self.ode_problem.sym
+ df = f(x).diff(x)
+ self.eqs = []
+ eq = eq_orig.collect(f(x), func = cancel)
+ eq = fraction(factor(eq))[0]
+ factors = Mul.make_args(factor(eq))
+ roots = [fac.as_base_exp() for fac in factors if len(fac.args)!=0]
+ if len(roots)>1 or roots[0][1]>1:
+ for base, expo in roots:
+ if base.has(f(x)):
+ self.eqs.append(base)
+ if len(self.eqs)>0:
+ return True
+ roots = solve(eq, df)
+ if len(roots)>0:
+ self.eqs = [(df - root) for root in roots]
+ # Avoid infinite recursion
+ matches = self.eqs != [eq_orig]
+ return matches
+ for i in factors:
+ if i.has(f(x)):
+ self.eqs.append(i)
+ return len(self.eqs)>0 and len(factors)>1
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ func = self.ode_problem.func.func
+ x = self.ode_problem.sym
+ eqns = self.eqs
+ sols = []
+ for eq in eqns:
+ try:
+ sol = dsolve(eq, func(x))
+ except NotImplementedError:
+ continue
+ else:
+ if isinstance(sol, list):
+ sols.extend(sol)
+ else:
+ sols.append(sol)
+
+ if sols == []:
+ raise NotImplementedError("The given ODE " + str(eq) + " cannot be solved by"
+ + " the factorable group method")
+ return sols
+
+
+class RiccatiSpecial(SinglePatternODESolver):
+ r"""
+ The general Riccati equation has the form
+
+ .. math:: dy/dx = f(x) y^2 + g(x) y + h(x)\text{.}
+
+ While it does not have a general solution [1], the "special" form, `dy/dx
+ = a y^2 - b x^c`, does have solutions in many cases [2]. This routine
+ returns a solution for `a(dy/dx) = b y^2 + c y/x + d/x^2` that is obtained
+ by using a suitable change of variables to reduce it to the special form
+ and is valid when neither `a` nor `b` are zero and either `c` or `d` is
+ zero.
+
+ >>> from sympy.abc import x, a, b, c, d
+ >>> from sympy import dsolve, checkodesol, pprint, Function
+ >>> f = Function('f')
+ >>> y = f(x)
+ >>> genform = a*y.diff(x) - (b*y**2 + c*y/x + d/x**2)
+ >>> sol = dsolve(genform, y, hint="Riccati_special_minus2")
+ >>> pprint(sol, wrap_line=False)
+ / / __________________ \\
+ | __________________ | / 2 ||
+ | / 2 | \/ 4*b*d - (a + c) *log(x)||
+ -|a + c - \/ 4*b*d - (a + c) *tan|C1 + ----------------------------||
+ \ \ 2*a //
+ f(x) = ------------------------------------------------------------------------
+ 2*b*x
+
+ >>> checkodesol(genform, sol, order=1)[0]
+ True
+
+ References
+ ==========
+
+ - https://www.maplesoft.com/support/help/Maple/view.aspx?path=odeadvisor/Riccati
+ - https://eqworld.ipmnet.ru/en/solutions/ode/ode0106.pdf -
+ https://eqworld.ipmnet.ru/en/solutions/ode/ode0123.pdf
+ """
+ hint = "Riccati_special_minus2"
+ has_integral = False
+ order = [1]
+
+ def _wilds(self, f, x, order):
+ a = Wild('a', exclude=[x, f(x), f(x).diff(x), 0])
+ b = Wild('b', exclude=[x, f(x), f(x).diff(x), 0])
+ c = Wild('c', exclude=[x, f(x), f(x).diff(x)])
+ d = Wild('d', exclude=[x, f(x), f(x).diff(x)])
+ return a, b, c, d
+
+ def _equation(self, fx, x, order):
+ a, b, c, d = self.wilds()
+ return a*fx.diff(x) + b*fx**2 + c*fx/x + d/x**2
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ a, b, c, d = self.wilds_match()
+ fx = self.ode_problem.func
+ x = self.ode_problem.sym
+ (C1,) = self.ode_problem.get_numbered_constants(num=1)
+ mu = sqrt(4*d*b - (a - c)**2)
+
+ gensol = Eq(fx, (a - c - mu*tan(mu/(2*a)*log(x) + C1))/(2*b*x))
+ return [gensol]
+
+
+class RationalRiccati(SinglePatternODESolver):
+ r"""
+ Gives general solutions to the first order Riccati differential
+ equations that have atleast one rational particular solution.
+
+ .. math :: y' = b_0(x) + b_1(x) y + b_2(x) y^2
+
+ where `b_0`, `b_1` and `b_2` are rational functions of `x`
+ with `b_2 \ne 0` (`b_2 = 0` would make it a Bernoulli equation).
+
+ Examples
+ ========
+
+ >>> from sympy import Symbol, Function, dsolve, checkodesol
+ >>> f = Function('f')
+ >>> x = Symbol('x')
+
+ >>> eq = -x**4*f(x)**2 + x**3*f(x).diff(x) + x**2*f(x) + 20
+ >>> sol = dsolve(eq, hint="1st_rational_riccati")
+ >>> sol
+ Eq(f(x), (4*C1 - 5*x**9 - 4)/(x**2*(C1 + x**9 - 1)))
+ >>> checkodesol(eq, sol)
+ (True, 0)
+
+ References
+ ==========
+
+ - Riccati ODE: https://en.wikipedia.org/wiki/Riccati_equation
+ - N. Thieu Vo - Rational and Algebraic Solutions of First-Order Algebraic ODEs:
+ Algorithm 11, pp. 78 - https://www3.risc.jku.at/publications/download/risc_5387/PhDThesisThieu.pdf
+ """
+ has_integral = False
+ hint = "1st_rational_riccati"
+ order = [1]
+
+ def _wilds(self, f, x, order):
+ b0 = Wild('b0', exclude=[f(x), f(x).diff(x)])
+ b1 = Wild('b1', exclude=[f(x), f(x).diff(x)])
+ b2 = Wild('b2', exclude=[f(x), f(x).diff(x)])
+ return (b0, b1, b2)
+
+ def _equation(self, fx, x, order):
+ b0, b1, b2 = self.wilds()
+ return fx.diff(x) - b0 - b1*fx - b2*fx**2
+
+ def _matches(self):
+ eq = self.ode_problem.eq_expanded
+ f = self.ode_problem.func.func
+ x = self.ode_problem.sym
+ order = self.ode_problem.order
+
+ if order != 1:
+ return False
+
+ match, funcs = match_riccati(eq, f, x)
+ if not match:
+ return False
+ _b0, _b1, _b2 = funcs
+ b0, b1, b2 = self.wilds()
+ self._wilds_match = match = {b0: _b0, b1: _b1, b2: _b2}
+ return True
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ # Match the equation
+ b0, b1, b2 = self.wilds_match()
+ fx = self.ode_problem.func
+ x = self.ode_problem.sym
+ return solve_riccati(fx, x, b0, b1, b2, gensol=True)
+
+
+class SecondNonlinearAutonomousConserved(SinglePatternODESolver):
+ r"""
+ Gives solution for the autonomous second order nonlinear
+ differential equation of the form
+
+ .. math :: f''(x) = g(f(x))
+
+ The solution for this differential equation can be computed
+ by multiplying by `f'(x)` and integrating on both sides,
+ converting it into a first order differential equation.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, symbols, dsolve
+ >>> f, g = symbols('f g', cls=Function)
+ >>> x = symbols('x')
+
+ >>> eq = f(x).diff(x, 2) - g(f(x))
+ >>> dsolve(eq, simplify=False)
+ [Eq(Integral(1/sqrt(C1 + 2*Integral(g(_u), _u)), (_u, f(x))), C2 + x),
+ Eq(Integral(1/sqrt(C1 + 2*Integral(g(_u), _u)), (_u, f(x))), C2 - x)]
+
+ >>> from sympy import exp, log
+ >>> eq = f(x).diff(x, 2) - exp(f(x)) + log(f(x))
+ >>> dsolve(eq, simplify=False)
+ [Eq(Integral(1/sqrt(-2*_u*log(_u) + 2*_u + C1 + 2*exp(_u)), (_u, f(x))), C2 + x),
+ Eq(Integral(1/sqrt(-2*_u*log(_u) + 2*_u + C1 + 2*exp(_u)), (_u, f(x))), C2 - x)]
+
+ References
+ ==========
+
+ - https://eqworld.ipmnet.ru/en/solutions/ode/ode0301.pdf
+ """
+ hint = "2nd_nonlinear_autonomous_conserved"
+ has_integral = True
+ order = [2]
+
+ def _wilds(self, f, x, order):
+ fy = Wild('fy', exclude=[0, f(x).diff(x), f(x).diff(x, 2)])
+ return (fy, )
+
+ def _equation(self, fx, x, order):
+ fy = self.wilds()[0]
+ return fx.diff(x, 2) + fy
+
+ def _verify(self, fx):
+ return self.ode_problem.is_autonomous
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ g = self.wilds_match()[0]
+ fx = self.ode_problem.func
+ x = self.ode_problem.sym
+ u = Dummy('u')
+ g = g.subs(fx, u)
+ C1, C2 = self.ode_problem.get_numbered_constants(num=2)
+ inside = -2*Integral(g, u) + C1
+ lhs = Integral(1/sqrt(inside), (u, fx))
+ return [Eq(lhs, C2 + x), Eq(lhs, C2 - x)]
+
+
+class Liouville(SinglePatternODESolver):
+ r"""
+ Solves 2nd order Liouville differential equations.
+
+ The general form of a Liouville ODE is
+
+ .. math:: \frac{d^2 y}{dx^2} + g(y) \left(\!
+ \frac{dy}{dx}\!\right)^2 + h(x)
+ \frac{dy}{dx}\text{.}
+
+ The general solution is:
+
+ >>> from sympy import Function, dsolve, Eq, pprint, diff
+ >>> from sympy.abc import x
+ >>> f, g, h = map(Function, ['f', 'g', 'h'])
+ >>> genform = Eq(diff(f(x),x,x) + g(f(x))*diff(f(x),x)**2 +
+ ... h(x)*diff(f(x),x), 0)
+ >>> pprint(genform)
+ 2 2
+ /d \ d d
+ g(f(x))*|--(f(x))| + h(x)*--(f(x)) + ---(f(x)) = 0
+ \dx / dx 2
+ dx
+ >>> pprint(dsolve(genform, f(x), hint='Liouville_Integral'))
+ f(x)
+ / /
+ | |
+ | / | /
+ | | | |
+ | - | h(x) dx | | g(y) dy
+ | | | |
+ | / | /
+ C1 + C2* | e dx + | e dy = 0
+ | |
+ / /
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, Eq, pprint
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> pprint(dsolve(diff(f(x), x, x) + diff(f(x), x)**2/f(x) +
+ ... diff(f(x), x)/x, f(x), hint='Liouville'))
+ ________________ ________________
+ [f(x) = -\/ C1 + C2*log(x) , f(x) = \/ C1 + C2*log(x) ]
+
+ References
+ ==========
+
+ - Goldstein and Braun, "Advanced Methods for the Solution of Differential
+ Equations", pp. 98
+ - https://www.maplesoft.com/support/help/Maple/view.aspx?path=odeadvisor/Liouville
+
+ # indirect doctest
+
+ """
+ hint = "Liouville"
+ has_integral = True
+ order = [2]
+
+ def _wilds(self, f, x, order):
+ d = Wild('d', exclude=[f(x).diff(x), f(x).diff(x, 2)])
+ e = Wild('e', exclude=[f(x).diff(x)])
+ k = Wild('k', exclude=[f(x).diff(x)])
+ return d, e, k
+
+ def _equation(self, fx, x, order):
+ # Liouville ODE in the form
+ # f(x).diff(x, 2) + g(f(x))*(f(x).diff(x))**2 + h(x)*f(x).diff(x)
+ # See Goldstein and Braun, "Advanced Methods for the Solution of
+ # Differential Equations", pg. 98
+ d, e, k = self.wilds()
+ return d*fx.diff(x, 2) + e*fx.diff(x)**2 + k*fx.diff(x)
+
+ def _verify(self, fx):
+ d, e, k = self.wilds_match()
+ self.y = Dummy('y')
+ x = self.ode_problem.sym
+ self.g = simplify(e/d).subs(fx, self.y)
+ self.h = simplify(k/d).subs(fx, self.y)
+ if self.y in self.h.free_symbols or x in self.g.free_symbols:
+ return False
+ return True
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ d, e, k = self.wilds_match()
+ fx = self.ode_problem.func
+ x = self.ode_problem.sym
+ C1, C2 = self.ode_problem.get_numbered_constants(num=2)
+ int = Integral(exp(Integral(self.g, self.y)), (self.y, None, fx))
+ gen_sol = Eq(int + C1*Integral(exp(-Integral(self.h, x)), x) + C2, 0)
+
+ return [gen_sol]
+
+
+class Separable(SinglePatternODESolver):
+ r"""
+ Solves separable 1st order differential equations.
+
+ This is any differential equation that can be written as `P(y)
+ \tfrac{dy}{dx} = Q(x)`. The solution can then just be found by
+ rearranging terms and integrating: `\int P(y) \,dy = \int Q(x) \,dx`.
+ This hint uses :py:meth:`sympy.simplify.simplify.separatevars` as its back
+ end, so if a separable equation is not caught by this solver, it is most
+ likely the fault of that function.
+ :py:meth:`~sympy.simplify.simplify.separatevars` is
+ smart enough to do most expansion and factoring necessary to convert a
+ separable equation `F(x, y)` into the proper form `P(x)\cdot{}Q(y)`. The
+ general solution is::
+
+ >>> from sympy import Function, dsolve, Eq, pprint
+ >>> from sympy.abc import x
+ >>> a, b, c, d, f = map(Function, ['a', 'b', 'c', 'd', 'f'])
+ >>> genform = Eq(a(x)*b(f(x))*f(x).diff(x), c(x)*d(f(x)))
+ >>> pprint(genform)
+ d
+ a(x)*b(f(x))*--(f(x)) = c(x)*d(f(x))
+ dx
+ >>> pprint(dsolve(genform, f(x), hint='separable_Integral'))
+ f(x)
+ / /
+ | |
+ | b(y) | c(x)
+ | ---- dy = C1 + | ---- dx
+ | d(y) | a(x)
+ | |
+ / /
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, Eq
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> pprint(dsolve(Eq(f(x)*f(x).diff(x) + x, 3*x*f(x)**2), f(x),
+ ... hint='separable', simplify=False))
+ / 2 \ 2
+ log\3*f (x) - 1/ x
+ ---------------- = C1 + --
+ 6 2
+
+ References
+ ==========
+
+ - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+ Dover 1963, pp. 52
+
+ # indirect doctest
+
+ """
+ hint = "separable"
+ has_integral = True
+ order = [1]
+
+ def _wilds(self, f, x, order):
+ d = Wild('d', exclude=[f(x).diff(x), f(x).diff(x, 2)])
+ e = Wild('e', exclude=[f(x).diff(x)])
+ return d, e
+
+ def _equation(self, fx, x, order):
+ d, e = self.wilds()
+ return d + e*fx.diff(x)
+
+ def _verify(self, fx):
+ d, e = self.wilds_match()
+ self.y = Dummy('y')
+ x = self.ode_problem.sym
+ d = separatevars(d.subs(fx, self.y))
+ e = separatevars(e.subs(fx, self.y))
+ # m1[coeff]*m1[x]*m1[y] + m2[coeff]*m2[x]*m2[y]*y'
+ self.m1 = separatevars(d, dict=True, symbols=(x, self.y))
+ self.m2 = separatevars(e, dict=True, symbols=(x, self.y))
+ if self.m1 and self.m2:
+ return True
+ return False
+
+ def _get_match_object(self):
+ fx = self.ode_problem.func
+ x = self.ode_problem.sym
+ return self.m1, self.m2, x, fx
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ m1, m2, x, fx = self._get_match_object()
+ (C1,) = self.ode_problem.get_numbered_constants(num=1)
+ int = Integral(m2['coeff']*m2[self.y]/m1[self.y],
+ (self.y, None, fx))
+ gen_sol = Eq(int, Integral(-m1['coeff']*m1[x]/
+ m2[x], x) + C1)
+ return [gen_sol]
+
+
+class SeparableReduced(Separable):
+ r"""
+ Solves a differential equation that can be reduced to the separable form.
+
+ The general form of this equation is
+
+ .. math:: y' + (y/x) H(x^n y) = 0\text{}.
+
+ This can be solved by substituting `u(y) = x^n y`. The equation then
+ reduces to the separable form `\frac{u'}{u (\mathrm{power} - H(u))} -
+ \frac{1}{x} = 0`.
+
+ The general solution is:
+
+ >>> from sympy import Function, dsolve, pprint
+ >>> from sympy.abc import x, n
+ >>> f, g = map(Function, ['f', 'g'])
+ >>> genform = f(x).diff(x) + (f(x)/x)*g(x**n*f(x))
+ >>> pprint(genform)
+ / n \
+ d f(x)*g\x *f(x)/
+ --(f(x)) + ---------------
+ dx x
+ >>> pprint(dsolve(genform, hint='separable_reduced'))
+ n
+ x *f(x)
+ /
+ |
+ | 1
+ | ------------ dy = C1 + log(x)
+ | y*(n - g(y))
+ |
+ /
+
+ See Also
+ ========
+ :obj:`sympy.solvers.ode.single.Separable`
+
+ Examples
+ ========
+
+ >>> from sympy import dsolve, Function, pprint
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> d = f(x).diff(x)
+ >>> eq = (x - x**2*f(x))*d - f(x)
+ >>> dsolve(eq, hint='separable_reduced')
+ [Eq(f(x), (1 - sqrt(C1*x**2 + 1))/x), Eq(f(x), (sqrt(C1*x**2 + 1) + 1)/x)]
+ >>> pprint(dsolve(eq, hint='separable_reduced'))
+ ___________ ___________
+ / 2 / 2
+ 1 - \/ C1*x + 1 \/ C1*x + 1 + 1
+ [f(x) = ------------------, f(x) = ------------------]
+ x x
+
+ References
+ ==========
+
+ - Joel Moses, "Symbolic Integration - The Stormy Decade", Communications
+ of the ACM, Volume 14, Number 8, August 1971, pp. 558
+ """
+ hint = "separable_reduced"
+ has_integral = True
+ order = [1]
+
+ def _degree(self, expr, x):
+ # Made this function to calculate the degree of
+ # x in an expression. If expr will be of form
+ # x**p*y, (wheare p can be variables/rationals) then it
+ # will return p.
+ for val in expr:
+ if val.has(x):
+ if isinstance(val, Pow) and val.as_base_exp()[0] == x:
+ return (val.as_base_exp()[1])
+ elif val == x:
+ return (val.as_base_exp()[1])
+ else:
+ return self._degree(val.args, x)
+ return 0
+
+ def _powers(self, expr):
+ # this function will return all the different relative power of x w.r.t f(x).
+ # expr = x**p * f(x)**q then it will return {p/q}.
+ pows = set()
+ fx = self.ode_problem.func
+ x = self.ode_problem.sym
+ self.y = Dummy('y')
+ if isinstance(expr, Add):
+ exprs = expr.atoms(Add)
+ elif isinstance(expr, Mul):
+ exprs = expr.atoms(Mul)
+ elif isinstance(expr, Pow):
+ exprs = expr.atoms(Pow)
+ else:
+ exprs = {expr}
+
+ for arg in exprs:
+ if arg.has(x):
+ _, u = arg.as_independent(x, fx)
+ pow = self._degree((u.subs(fx, self.y), ), x)/self._degree((u.subs(fx, self.y), ), self.y)
+ pows.add(pow)
+ return pows
+
+ def _verify(self, fx):
+ num, den = self.wilds_match()
+ x = self.ode_problem.sym
+ factor = simplify(x/fx*num/den)
+ # Try representing factor in terms of x^n*y
+ # where n is lowest power of x in factor;
+ # first remove terms like sqrt(2)*3 from factor.atoms(Mul)
+ num, dem = factor.as_numer_denom()
+ num = expand(num)
+ dem = expand(dem)
+ pows = self._powers(num)
+ pows.update(self._powers(dem))
+ pows = list(pows)
+ if(len(pows)==1) and pows[0]!=zoo:
+ self.t = Dummy('t')
+ self.r2 = {'t': self.t}
+ num = num.subs(x**pows[0]*fx, self.t)
+ dem = dem.subs(x**pows[0]*fx, self.t)
+ test = num/dem
+ free = test.free_symbols
+ if len(free) == 1 and free.pop() == self.t:
+ self.r2.update({'power' : pows[0], 'u' : test})
+ return True
+ return False
+ return False
+
+ def _get_match_object(self):
+ fx = self.ode_problem.func
+ x = self.ode_problem.sym
+ u = self.r2['u'].subs(self.r2['t'], self.y)
+ ycoeff = 1/(self.y*(self.r2['power'] - u))
+ m1 = {self.y: 1, x: -1/x, 'coeff': 1}
+ m2 = {self.y: ycoeff, x: 1, 'coeff': 1}
+ return m1, m2, x, x**self.r2['power']*fx
+
+
+class HomogeneousCoeffSubsDepDivIndep(SinglePatternODESolver):
+ r"""
+ Solves a 1st order differential equation with homogeneous coefficients
+ using the substitution `u_1 = \frac{\text{}}{\text{}}`.
+
+ This is a differential equation
+
+ .. math:: P(x, y) + Q(x, y) dy/dx = 0
+
+ such that `P` and `Q` are homogeneous and of the same order. A function
+ `F(x, y)` is homogeneous of order `n` if `F(x t, y t) = t^n F(x, y)`.
+ Equivalently, `F(x, y)` can be rewritten as `G(y/x)` or `H(x/y)`. See
+ also the docstring of :py:meth:`~sympy.solvers.ode.homogeneous_order`.
+
+ If the coefficients `P` and `Q` in the differential equation above are
+ homogeneous functions of the same order, then it can be shown that the
+ substitution `y = u_1 x` (i.e. `u_1 = y/x`) will turn the differential
+ equation into an equation separable in the variables `x` and `u`. If
+ `h(u_1)` is the function that results from making the substitution `u_1 =
+ f(x)/x` on `P(x, f(x))` and `g(u_2)` is the function that results from the
+ substitution on `Q(x, f(x))` in the differential equation `P(x, f(x)) +
+ Q(x, f(x)) f'(x) = 0`, then the general solution is::
+
+ >>> from sympy import Function, dsolve, pprint
+ >>> from sympy.abc import x
+ >>> f, g, h = map(Function, ['f', 'g', 'h'])
+ >>> genform = g(f(x)/x) + h(f(x)/x)*f(x).diff(x)
+ >>> pprint(genform)
+ /f(x)\ /f(x)\ d
+ g|----| + h|----|*--(f(x))
+ \ x / \ x / dx
+ >>> pprint(dsolve(genform, f(x),
+ ... hint='1st_homogeneous_coeff_subs_dep_div_indep_Integral'))
+ f(x)
+ ----
+ x
+ /
+ |
+ | -h(u1)
+ log(x) = C1 + | ---------------- d(u1)
+ | u1*h(u1) + g(u1)
+ |
+ /
+
+ Where `u_1 h(u_1) + g(u_1) \ne 0` and `x \ne 0`.
+
+ See also the docstrings of
+ :obj:`~sympy.solvers.ode.single.HomogeneousCoeffBest` and
+ :obj:`~sympy.solvers.ode.single.HomogeneousCoeffSubsIndepDivDep`.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> pprint(dsolve(2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x), f(x),
+ ... hint='1st_homogeneous_coeff_subs_dep_div_indep', simplify=False))
+ / 3 \
+ |3*f(x) f (x)|
+ log|------ + -----|
+ | x 3 |
+ \ x /
+ log(x) = log(C1) - -------------------
+ 3
+
+ References
+ ==========
+
+ - https://en.wikipedia.org/wiki/Homogeneous_differential_equation
+ - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+ Dover 1963, pp. 59
+
+ # indirect doctest
+
+ """
+ hint = "1st_homogeneous_coeff_subs_dep_div_indep"
+ has_integral = True
+ order = [1]
+
+ def _wilds(self, f, x, order):
+ d = Wild('d', exclude=[f(x).diff(x), f(x).diff(x, 2)])
+ e = Wild('e', exclude=[f(x).diff(x)])
+ return d, e
+
+ def _equation(self, fx, x, order):
+ d, e = self.wilds()
+ return d + e*fx.diff(x)
+
+ def _verify(self, fx):
+ self.d, self.e = self.wilds_match()
+ self.y = Dummy('y')
+ x = self.ode_problem.sym
+ self.d = separatevars(self.d.subs(fx, self.y))
+ self.e = separatevars(self.e.subs(fx, self.y))
+ ordera = homogeneous_order(self.d, x, self.y)
+ orderb = homogeneous_order(self.e, x, self.y)
+ if ordera == orderb and ordera is not None:
+ self.u = Dummy('u')
+ if simplify((self.d + self.u*self.e).subs({x: 1, self.y: self.u})) != 0:
+ return True
+ return False
+ return False
+
+ def _get_match_object(self):
+ fx = self.ode_problem.func
+ x = self.ode_problem.sym
+ self.u1 = Dummy('u1')
+ xarg = 0
+ yarg = 0
+ return [self.d, self.e, fx, x, self.u, self.u1, self.y, xarg, yarg]
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ d, e, fx, x, u, u1, y, xarg, yarg = self._get_match_object()
+ (C1,) = self.ode_problem.get_numbered_constants(num=1)
+ int = Integral(
+ (-e/(d + u1*e)).subs({x: 1, y: u1}),
+ (u1, None, fx/x))
+ sol = logcombine(Eq(log(x), int + log(C1)), force=True)
+ gen_sol = sol.subs(fx, u).subs(((u, u - yarg), (x, x - xarg), (u, fx)))
+ return [gen_sol]
+
+
+class HomogeneousCoeffSubsIndepDivDep(SinglePatternODESolver):
+ r"""
+ Solves a 1st order differential equation with homogeneous coefficients
+ using the substitution `u_2 = \frac{\text{}}{\text{}}`.
+
+ This is a differential equation
+
+ .. math:: P(x, y) + Q(x, y) dy/dx = 0
+
+ such that `P` and `Q` are homogeneous and of the same order. A function
+ `F(x, y)` is homogeneous of order `n` if `F(x t, y t) = t^n F(x, y)`.
+ Equivalently, `F(x, y)` can be rewritten as `G(y/x)` or `H(x/y)`. See
+ also the docstring of :py:meth:`~sympy.solvers.ode.homogeneous_order`.
+
+ If the coefficients `P` and `Q` in the differential equation above are
+ homogeneous functions of the same order, then it can be shown that the
+ substitution `x = u_2 y` (i.e. `u_2 = x/y`) will turn the differential
+ equation into an equation separable in the variables `y` and `u_2`. If
+ `h(u_2)` is the function that results from making the substitution `u_2 =
+ x/f(x)` on `P(x, f(x))` and `g(u_2)` is the function that results from the
+ substitution on `Q(x, f(x))` in the differential equation `P(x, f(x)) +
+ Q(x, f(x)) f'(x) = 0`, then the general solution is:
+
+ >>> from sympy import Function, dsolve, pprint
+ >>> from sympy.abc import x
+ >>> f, g, h = map(Function, ['f', 'g', 'h'])
+ >>> genform = g(x/f(x)) + h(x/f(x))*f(x).diff(x)
+ >>> pprint(genform)
+ / x \ / x \ d
+ g|----| + h|----|*--(f(x))
+ \f(x)/ \f(x)/ dx
+ >>> pprint(dsolve(genform, f(x),
+ ... hint='1st_homogeneous_coeff_subs_indep_div_dep_Integral'))
+ x
+ ----
+ f(x)
+ /
+ |
+ | -g(u1)
+ | ---------------- d(u1)
+ | u1*g(u1) + h(u1)
+ |
+ /
+
+ f(x) = C1*e
+
+ Where `u_1 g(u_1) + h(u_1) \ne 0` and `f(x) \ne 0`.
+
+ See also the docstrings of
+ :obj:`~sympy.solvers.ode.single.HomogeneousCoeffBest` and
+ :obj:`~sympy.solvers.ode.single.HomogeneousCoeffSubsDepDivIndep`.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, pprint, dsolve
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> pprint(dsolve(2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x), f(x),
+ ... hint='1st_homogeneous_coeff_subs_indep_div_dep',
+ ... simplify=False))
+ / 2 \
+ | 3*x |
+ log|----- + 1|
+ | 2 |
+ \f (x) /
+ log(f(x)) = log(C1) - --------------
+ 3
+
+ References
+ ==========
+
+ - https://en.wikipedia.org/wiki/Homogeneous_differential_equation
+ - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+ Dover 1963, pp. 59
+
+ # indirect doctest
+
+ """
+ hint = "1st_homogeneous_coeff_subs_indep_div_dep"
+ has_integral = True
+ order = [1]
+
+ def _wilds(self, f, x, order):
+ d = Wild('d', exclude=[f(x).diff(x), f(x).diff(x, 2)])
+ e = Wild('e', exclude=[f(x).diff(x)])
+ return d, e
+
+ def _equation(self, fx, x, order):
+ d, e = self.wilds()
+ return d + e*fx.diff(x)
+
+ def _verify(self, fx):
+ self.d, self.e = self.wilds_match()
+ self.y = Dummy('y')
+ x = self.ode_problem.sym
+ self.d = separatevars(self.d.subs(fx, self.y))
+ self.e = separatevars(self.e.subs(fx, self.y))
+ ordera = homogeneous_order(self.d, x, self.y)
+ orderb = homogeneous_order(self.e, x, self.y)
+ if ordera == orderb and ordera is not None:
+ self.u = Dummy('u')
+ if simplify((self.e + self.u*self.d).subs({x: self.u, self.y: 1})) != 0:
+ return True
+ return False
+ return False
+
+ def _get_match_object(self):
+ fx = self.ode_problem.func
+ x = self.ode_problem.sym
+ self.u1 = Dummy('u1')
+ xarg = 0
+ yarg = 0
+ return [self.d, self.e, fx, x, self.u, self.u1, self.y, xarg, yarg]
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ d, e, fx, x, u, u1, y, xarg, yarg = self._get_match_object()
+ (C1,) = self.ode_problem.get_numbered_constants(num=1)
+ int = Integral(simplify((-d/(e + u1*d)).subs({x: u1, y: 1})), (u1, None, x/fx)) # type: ignore
+ sol = logcombine(Eq(log(fx), int + log(C1)), force=True)
+ gen_sol = sol.subs(fx, u).subs(((u, u - yarg), (x, x - xarg), (u, fx)))
+ return [gen_sol]
+
+
+class HomogeneousCoeffBest(HomogeneousCoeffSubsIndepDivDep, HomogeneousCoeffSubsDepDivIndep):
+ r"""
+ Returns the best solution to an ODE from the two hints
+ ``1st_homogeneous_coeff_subs_dep_div_indep`` and
+ ``1st_homogeneous_coeff_subs_indep_div_dep``.
+
+ This is as determined by :py:meth:`~sympy.solvers.ode.ode.ode_sol_simplicity`.
+
+ See the
+ :obj:`~sympy.solvers.ode.single.HomogeneousCoeffSubsIndepDivDep`
+ and
+ :obj:`~sympy.solvers.ode.single.HomogeneousCoeffSubsDepDivIndep`
+ docstrings for more information on these hints. Note that there is no
+ ``ode_1st_homogeneous_coeff_best_Integral`` hint.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, pprint
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> pprint(dsolve(2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x), f(x),
+ ... hint='1st_homogeneous_coeff_best', simplify=False))
+ / 2 \
+ | 3*x |
+ log|----- + 1|
+ | 2 |
+ \f (x) /
+ log(f(x)) = log(C1) - --------------
+ 3
+
+ References
+ ==========
+
+ - https://en.wikipedia.org/wiki/Homogeneous_differential_equation
+ - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+ Dover 1963, pp. 59
+
+ # indirect doctest
+
+ """
+ hint = "1st_homogeneous_coeff_best"
+ has_integral = False
+ order = [1]
+
+ def _verify(self, fx):
+ if HomogeneousCoeffSubsIndepDivDep._verify(self, fx) and HomogeneousCoeffSubsDepDivIndep._verify(self, fx):
+ return True
+ return False
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ # There are two substitutions that solve the equation, u1=y/x and u2=x/y
+ # # They produce different integrals, so try them both and see which
+ # # one is easier
+ sol1 = HomogeneousCoeffSubsIndepDivDep._get_general_solution(self)
+ sol2 = HomogeneousCoeffSubsDepDivIndep._get_general_solution(self)
+ fx = self.ode_problem.func
+ if simplify_flag:
+ sol1 = odesimp(self.ode_problem.eq, *sol1, fx, "1st_homogeneous_coeff_subs_indep_div_dep")
+ sol2 = odesimp(self.ode_problem.eq, *sol2, fx, "1st_homogeneous_coeff_subs_dep_div_indep")
+ return min([sol1, sol2], key=lambda x: ode_sol_simplicity(x, fx, trysolving=not simplify))
+
+
+class LinearCoefficients(HomogeneousCoeffBest):
+ r"""
+ Solves a differential equation with linear coefficients.
+
+ The general form of a differential equation with linear coefficients is
+
+ .. math:: y' + F\left(\!\frac{a_1 x + b_1 y + c_1}{a_2 x + b_2 y +
+ c_2}\!\right) = 0\text{,}
+
+ where `a_1`, `b_1`, `c_1`, `a_2`, `b_2`, `c_2` are constants and `a_1 b_2
+ - a_2 b_1 \ne 0`.
+
+ This can be solved by substituting:
+
+ .. math:: x = x' + \frac{b_2 c_1 - b_1 c_2}{a_2 b_1 - a_1 b_2}
+
+ y = y' + \frac{a_1 c_2 - a_2 c_1}{a_2 b_1 - a_1
+ b_2}\text{.}
+
+ This substitution reduces the equation to a homogeneous differential
+ equation.
+
+ See Also
+ ========
+ :obj:`sympy.solvers.ode.single.HomogeneousCoeffBest`
+ :obj:`sympy.solvers.ode.single.HomogeneousCoeffSubsIndepDivDep`
+ :obj:`sympy.solvers.ode.single.HomogeneousCoeffSubsDepDivIndep`
+
+ Examples
+ ========
+
+ >>> from sympy import dsolve, Function, pprint
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> df = f(x).diff(x)
+ >>> eq = (x + f(x) + 1)*df + (f(x) - 6*x + 1)
+ >>> dsolve(eq, hint='linear_coefficients')
+ [Eq(f(x), -x - sqrt(C1 + 7*x**2) - 1), Eq(f(x), -x + sqrt(C1 + 7*x**2) - 1)]
+ >>> pprint(dsolve(eq, hint='linear_coefficients'))
+ ___________ ___________
+ / 2 / 2
+ [f(x) = -x - \/ C1 + 7*x - 1, f(x) = -x + \/ C1 + 7*x - 1]
+
+
+ References
+ ==========
+
+ - Joel Moses, "Symbolic Integration - The Stormy Decade", Communications
+ of the ACM, Volume 14, Number 8, August 1971, pp. 558
+ """
+ hint = "linear_coefficients"
+ has_integral = True
+ order = [1]
+
+ def _wilds(self, f, x, order):
+ d = Wild('d', exclude=[f(x).diff(x), f(x).diff(x, 2)])
+ e = Wild('e', exclude=[f(x).diff(x)])
+ return d, e
+
+ def _equation(self, fx, x, order):
+ d, e = self.wilds()
+ return d + e*fx.diff(x)
+
+ def _verify(self, fx):
+ self.d, self.e = self.wilds_match()
+ a, b = self.wilds()
+ F = self.d/self.e
+ x = self.ode_problem.sym
+ params = self._linear_coeff_match(F, fx)
+ if params:
+ self.xarg, self.yarg = params
+ u = Dummy('u')
+ t = Dummy('t')
+ self.y = Dummy('y')
+ # Dummy substitution for df and f(x).
+ dummy_eq = self.ode_problem.eq.subs(((fx.diff(x), t), (fx, u)))
+ reps = ((x, x + self.xarg), (u, u + self.yarg), (t, fx.diff(x)), (u, fx))
+ dummy_eq = simplify(dummy_eq.subs(reps))
+ # get the re-cast values for e and d
+ r2 = collect(expand(dummy_eq), [fx.diff(x), fx]).match(a*fx.diff(x) + b)
+ if r2:
+ self.d, self.e = r2[b], r2[a]
+ orderd = homogeneous_order(self.d, x, fx)
+ ordere = homogeneous_order(self.e, x, fx)
+ if orderd == ordere and orderd is not None:
+ self.d = self.d.subs(fx, self.y)
+ self.e = self.e.subs(fx, self.y)
+ return True
+ return False
+ return False
+
+ def _linear_coeff_match(self, expr, func):
+ r"""
+ Helper function to match hint ``linear_coefficients``.
+
+ Matches the expression to the form `(a_1 x + b_1 f(x) + c_1)/(a_2 x + b_2
+ f(x) + c_2)` where the following conditions hold:
+
+ 1. `a_1`, `b_1`, `c_1`, `a_2`, `b_2`, `c_2` are Rationals;
+ 2. `c_1` or `c_2` are not equal to zero;
+ 3. `a_2 b_1 - a_1 b_2` is not equal to zero.
+
+ Return ``xarg``, ``yarg`` where
+
+ 1. ``xarg`` = `(b_2 c_1 - b_1 c_2)/(a_2 b_1 - a_1 b_2)`
+ 2. ``yarg`` = `(a_1 c_2 - a_2 c_1)/(a_2 b_1 - a_1 b_2)`
+
+
+ Examples
+ ========
+
+ >>> from sympy import Function, sin
+ >>> from sympy.abc import x
+ >>> from sympy.solvers.ode.single import LinearCoefficients
+ >>> f = Function('f')
+ >>> eq = (-25*f(x) - 8*x + 62)/(4*f(x) + 11*x - 11)
+ >>> obj = LinearCoefficients(eq)
+ >>> obj._linear_coeff_match(eq, f(x))
+ (1/9, 22/9)
+ >>> eq = sin((-5*f(x) - 8*x + 6)/(4*f(x) + x - 1))
+ >>> obj = LinearCoefficients(eq)
+ >>> obj._linear_coeff_match(eq, f(x))
+ (19/27, 2/27)
+ >>> eq = sin(f(x)/x)
+ >>> obj = LinearCoefficients(eq)
+ >>> obj._linear_coeff_match(eq, f(x))
+
+ """
+ f = func.func
+ x = func.args[0]
+ def abc(eq):
+ r'''
+ Internal function of _linear_coeff_match
+ that returns Rationals a, b, c
+ if eq is a*x + b*f(x) + c, else None.
+ '''
+ eq = _mexpand(eq)
+ c = eq.as_independent(x, f(x), as_Add=True)[0]
+ if not c.is_Rational:
+ return
+ a = eq.coeff(x)
+ if not a.is_Rational:
+ return
+ b = eq.coeff(f(x))
+ if not b.is_Rational:
+ return
+ if eq == a*x + b*f(x) + c:
+ return a, b, c
+
+ def match(arg):
+ r'''
+ Internal function of _linear_coeff_match that returns Rationals a1,
+ b1, c1, a2, b2, c2 and a2*b1 - a1*b2 of the expression (a1*x + b1*f(x)
+ + c1)/(a2*x + b2*f(x) + c2) if one of c1 or c2 and a2*b1 - a1*b2 is
+ non-zero, else None.
+ '''
+ n, d = arg.together().as_numer_denom()
+ m = abc(n)
+ if m is not None:
+ a1, b1, c1 = m
+ m = abc(d)
+ if m is not None:
+ a2, b2, c2 = m
+ d = a2*b1 - a1*b2
+ if (c1 or c2) and d:
+ return a1, b1, c1, a2, b2, c2, d
+
+ m = [fi.args[0] for fi in expr.atoms(Function) if fi.func != f and
+ len(fi.args) == 1 and not fi.args[0].is_Function] or {expr}
+ m1 = match(m.pop())
+ if m1 and all(match(mi) == m1 for mi in m):
+ a1, b1, c1, a2, b2, c2, denom = m1
+ return (b2*c1 - b1*c2)/denom, (a1*c2 - a2*c1)/denom
+
+ def _get_match_object(self):
+ fx = self.ode_problem.func
+ x = self.ode_problem.sym
+ self.u1 = Dummy('u1')
+ u = Dummy('u')
+ return [self.d, self.e, fx, x, u, self.u1, self.y, self.xarg, self.yarg]
+
+
+class NthOrderReducible(SingleODESolver):
+ r"""
+ Solves ODEs that only involve derivatives of the dependent variable using
+ a substitution of the form `f^n(x) = g(x)`.
+
+ For example any second order ODE of the form `f''(x) = h(f'(x), x)` can be
+ transformed into a pair of 1st order ODEs `g'(x) = h(g(x), x)` and
+ `f'(x) = g(x)`. Usually the 1st order ODE for `g` is easier to solve. If
+ that gives an explicit solution for `g` then `f` is found simply by
+ integration.
+
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, Eq
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> eq = Eq(x*f(x).diff(x)**2 + f(x).diff(x, 2), 0)
+ >>> dsolve(eq, f(x), hint='nth_order_reducible')
+ ... # doctest: +NORMALIZE_WHITESPACE
+ Eq(f(x), C1 - sqrt(-1/C2)*log(-C2*sqrt(-1/C2) + x) + sqrt(-1/C2)*log(C2*sqrt(-1/C2) + x))
+
+ """
+ hint = "nth_order_reducible"
+ has_integral = False
+
+ def _matches(self):
+ # Any ODE that can be solved with a substitution and
+ # repeated integration e.g.:
+ # `d^2/dx^2(y) + x*d/dx(y) = constant
+ #f'(x) must be finite for this to work
+ eq = self.ode_problem.eq_preprocessed
+ func = self.ode_problem.func
+ x = self.ode_problem.sym
+ r"""
+ Matches any differential equation that can be rewritten with a smaller
+ order. Only derivatives of ``func`` alone, wrt a single variable,
+ are considered, and only in them should ``func`` appear.
+ """
+ # ODE only handles functions of 1 variable so this affirms that state
+ assert len(func.args) == 1
+ vc = [d.variable_count[0] for d in eq.atoms(Derivative)
+ if d.expr == func and len(d.variable_count) == 1]
+ ords = [c for v, c in vc if v == x]
+ if len(ords) < 2:
+ return False
+ self.smallest = min(ords)
+ # make sure func does not appear outside of derivatives
+ D = Dummy()
+ if eq.subs(func.diff(x, self.smallest), D).has(func):
+ return False
+ return True
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ eq = self.ode_problem.eq
+ f = self.ode_problem.func.func
+ x = self.ode_problem.sym
+ n = self.smallest
+ # get a unique function name for g
+ names = [a.name for a in eq.atoms(AppliedUndef)]
+ while True:
+ name = Dummy().name
+ if name not in names:
+ g = Function(name)
+ break
+ w = f(x).diff(x, n)
+ geq = eq.subs(w, g(x))
+ gsol = dsolve(geq, g(x))
+
+ if not isinstance(gsol, list):
+ gsol = [gsol]
+
+ # Might be multiple solutions to the reduced ODE:
+ fsol = []
+ for gsoli in gsol:
+ fsoli = dsolve(gsoli.subs(g(x), w), f(x)) # or do integration n times
+ fsol.append(fsoli)
+
+ return fsol
+
+
+class SecondHypergeometric(SingleODESolver):
+ r"""
+ Solves 2nd order linear differential equations.
+
+ It computes special function solutions which can be expressed using the
+ 2F1, 1F1 or 0F1 hypergeometric functions.
+
+ .. math:: y'' + A(x) y' + B(x) y = 0\text{,}
+
+ where `A` and `B` are rational functions.
+
+ These kinds of differential equations have solution of non-Liouvillian form.
+
+ Given linear ODE can be obtained from 2F1 given by
+
+ .. math:: (x^2 - x) y'' + ((a + b + 1) x - c) y' + b a y = 0\text{,}
+
+ where {a, b, c} are arbitrary constants.
+
+ Notes
+ =====
+
+ The algorithm should find any solution of the form
+
+ .. math:: y = P(x) _pF_q(..; ..;\frac{\alpha x^k + \beta}{\gamma x^k + \delta})\text{,}
+
+ where pFq is any of 2F1, 1F1 or 0F1 and `P` is an "arbitrary function".
+ Currently only the 2F1 case is implemented in SymPy but the other cases are
+ described in the paper and could be implemented in future (contributions
+ welcome!).
+
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, pprint
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> eq = (x*x - x)*f(x).diff(x,2) + (5*x - 1)*f(x).diff(x) + 4*f(x)
+ >>> pprint(dsolve(eq, f(x), '2nd_hypergeometric'))
+ _
+ / / 4 \\ |_ /-1, -1 | \
+ |C1 + C2*|log(x) + -----||* | | | x|
+ \ \ x + 1// 2 1 \ 1 | /
+ f(x) = --------------------------------------------
+ 3
+ (x - 1)
+
+
+ References
+ ==========
+
+ - "Non-Liouvillian solutions for second order linear ODEs" by L. Chan, E.S. Cheb-Terrab
+
+ """
+ hint = "2nd_hypergeometric"
+ has_integral = True
+
+ def _matches(self):
+ eq = self.ode_problem.eq_preprocessed
+ func = self.ode_problem.func
+ r = match_2nd_hypergeometric(eq, func)
+ self.match_object = None
+ if r:
+ A, B = r
+ d = equivalence_hypergeometric(A, B, func)
+ if d:
+ if d['type'] == "2F1":
+ self.match_object = match_2nd_2F1_hypergeometric(d['I0'], d['k'], d['sing_point'], func)
+ if self.match_object is not None:
+ self.match_object.update({'A':A, 'B':B})
+ # We can extend it for 1F1 and 0F1 type also.
+ return self.match_object is not None
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ eq = self.ode_problem.eq
+ func = self.ode_problem.func
+ if self.match_object['type'] == "2F1":
+ sol = get_sol_2F1_hypergeometric(eq, func, self.match_object)
+ if sol is None:
+ raise NotImplementedError("The given ODE " + str(eq) + " cannot be solved by"
+ + " the hypergeometric method")
+
+ return [sol]
+
+
+class NthLinearConstantCoeffHomogeneous(SingleODESolver):
+ r"""
+ Solves an `n`\th order linear homogeneous differential equation with
+ constant coefficients.
+
+ This is an equation of the form
+
+ .. math:: a_n f^{(n)}(x) + a_{n-1} f^{(n-1)}(x) + \cdots + a_1 f'(x)
+ + a_0 f(x) = 0\text{.}
+
+ These equations can be solved in a general manner, by taking the roots of
+ the characteristic equation `a_n m^n + a_{n-1} m^{n-1} + \cdots + a_1 m +
+ a_0 = 0`. The solution will then be the sum of `C_n x^i e^{r x}` terms,
+ for each where `C_n` is an arbitrary constant, `r` is a root of the
+ characteristic equation and `i` is one of each from 0 to the multiplicity
+ of the root - 1 (for example, a root 3 of multiplicity 2 would create the
+ terms `C_1 e^{3 x} + C_2 x e^{3 x}`). The exponential is usually expanded
+ for complex roots using Euler's equation `e^{I x} = \cos(x) + I \sin(x)`.
+ Complex roots always come in conjugate pairs in polynomials with real
+ coefficients, so the two roots will be represented (after simplifying the
+ constants) as `e^{a x} \left(C_1 \cos(b x) + C_2 \sin(b x)\right)`.
+
+ If SymPy cannot find exact roots to the characteristic equation, a
+ :py:class:`~sympy.polys.rootoftools.ComplexRootOf` instance will be return
+ instead.
+
+ >>> from sympy import Function, dsolve
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> dsolve(f(x).diff(x, 5) + 10*f(x).diff(x) - 2*f(x), f(x),
+ ... hint='nth_linear_constant_coeff_homogeneous')
+ ... # doctest: +NORMALIZE_WHITESPACE
+ Eq(f(x), C5*exp(x*CRootOf(_x**5 + 10*_x - 2, 0))
+ + (C1*sin(x*im(CRootOf(_x**5 + 10*_x - 2, 1)))
+ + C2*cos(x*im(CRootOf(_x**5 + 10*_x - 2, 1))))*exp(x*re(CRootOf(_x**5 + 10*_x - 2, 1)))
+ + (C3*sin(x*im(CRootOf(_x**5 + 10*_x - 2, 3)))
+ + C4*cos(x*im(CRootOf(_x**5 + 10*_x - 2, 3))))*exp(x*re(CRootOf(_x**5 + 10*_x - 2, 3))))
+
+ Note that because this method does not involve integration, there is no
+ ``nth_linear_constant_coeff_homogeneous_Integral`` hint.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, pprint
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> pprint(dsolve(f(x).diff(x, 4) + 2*f(x).diff(x, 3) -
+ ... 2*f(x).diff(x, 2) - 6*f(x).diff(x) + 5*f(x), f(x),
+ ... hint='nth_linear_constant_coeff_homogeneous'))
+ x -2*x
+ f(x) = (C1 + C2*x)*e + (C3*sin(x) + C4*cos(x))*e
+
+ References
+ ==========
+
+ - https://en.wikipedia.org/wiki/Linear_differential_equation section:
+ Nonhomogeneous_equation_with_constant_coefficients
+ - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+ Dover 1963, pp. 211
+
+ # indirect doctest
+
+ """
+ hint = "nth_linear_constant_coeff_homogeneous"
+ has_integral = False
+
+ def _matches(self):
+ eq = self.ode_problem.eq_high_order_free
+ func = self.ode_problem.func
+ order = self.ode_problem.order
+ x = self.ode_problem.sym
+ self.r = self.ode_problem.get_linear_coefficients(eq, func, order)
+ if order and self.r and not any(self.r[i].has(x) for i in self.r if i >= 0):
+ if not self.r[-1]:
+ return True
+ else:
+ return False
+ return False
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ fx = self.ode_problem.func
+ order = self.ode_problem.order
+ roots, collectterms = _get_const_characteristic_eq_sols(self.r, fx, order)
+ # A generator of constants
+ constants = self.ode_problem.get_numbered_constants(num=len(roots))
+ gsol = Add(*[i*j for (i, j) in zip(constants, roots)])
+ gsol = Eq(fx, gsol)
+ if simplify_flag:
+ gsol = _get_simplified_sol([gsol], fx, collectterms)
+
+ return [gsol]
+
+
+class NthLinearConstantCoeffVariationOfParameters(SingleODESolver):
+ r"""
+ Solves an `n`\th order linear differential equation with constant
+ coefficients using the method of variation of parameters.
+
+ This method works on any differential equations of the form
+
+ .. math:: f^{(n)}(x) + a_{n-1} f^{(n-1)}(x) + \cdots + a_1 f'(x) + a_0
+ f(x) = P(x)\text{.}
+
+ This method works by assuming that the particular solution takes the form
+
+ .. math:: \sum_{x=1}^{n} c_i(x) y_i(x)\text{,}
+
+ where `y_i` is the `i`\th solution to the homogeneous equation. The
+ solution is then solved using Wronskian's and Cramer's Rule. The
+ particular solution is given by
+
+ .. math:: \sum_{x=1}^n \left( \int \frac{W_i(x)}{W(x)} \,dx
+ \right) y_i(x) \text{,}
+
+ where `W(x)` is the Wronskian of the fundamental system (the system of `n`
+ linearly independent solutions to the homogeneous equation), and `W_i(x)`
+ is the Wronskian of the fundamental system with the `i`\th column replaced
+ with `[0, 0, \cdots, 0, P(x)]`.
+
+ This method is general enough to solve any `n`\th order inhomogeneous
+ linear differential equation with constant coefficients, but sometimes
+ SymPy cannot simplify the Wronskian well enough to integrate it. If this
+ method hangs, try using the
+ ``nth_linear_constant_coeff_variation_of_parameters_Integral`` hint and
+ simplifying the integrals manually. Also, prefer using
+ ``nth_linear_constant_coeff_undetermined_coefficients`` when it
+ applies, because it does not use integration, making it faster and more
+ reliable.
+
+ Warning, using simplify=False with
+ 'nth_linear_constant_coeff_variation_of_parameters' in
+ :py:meth:`~sympy.solvers.ode.dsolve` may cause it to hang, because it will
+ not attempt to simplify the Wronskian before integrating. It is
+ recommended that you only use simplify=False with
+ 'nth_linear_constant_coeff_variation_of_parameters_Integral' for this
+ method, especially if the solution to the homogeneous equation has
+ trigonometric functions in it.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, pprint, exp, log
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> pprint(dsolve(f(x).diff(x, 3) - 3*f(x).diff(x, 2) +
+ ... 3*f(x).diff(x) - f(x) - exp(x)*log(x), f(x),
+ ... hint='nth_linear_constant_coeff_variation_of_parameters'))
+ / / / x*log(x) 11*x\\\ x
+ f(x) = |C1 + x*|C2 + x*|C3 + -------- - ----|||*e
+ \ \ \ 6 36 ///
+
+ References
+ ==========
+
+ - https://en.wikipedia.org/wiki/Variation_of_parameters
+ - https://planetmath.org/VariationOfParameters
+ - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+ Dover 1963, pp. 233
+
+ # indirect doctest
+
+ """
+ hint = "nth_linear_constant_coeff_variation_of_parameters"
+ has_integral = True
+
+ def _matches(self):
+ eq = self.ode_problem.eq_high_order_free
+ func = self.ode_problem.func
+ order = self.ode_problem.order
+ x = self.ode_problem.sym
+ self.r = self.ode_problem.get_linear_coefficients(eq, func, order)
+
+ if order and self.r and not any(self.r[i].has(x) for i in self.r if i >= 0):
+ if self.r[-1]:
+ return True
+ else:
+ return False
+ return False
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ eq = self.ode_problem.eq_high_order_free
+ f = self.ode_problem.func.func
+ x = self.ode_problem.sym
+ order = self.ode_problem.order
+ roots, collectterms = _get_const_characteristic_eq_sols(self.r, f(x), order)
+ # A generator of constants
+ constants = self.ode_problem.get_numbered_constants(num=len(roots))
+ homogen_sol = Add(*[i*j for (i, j) in zip(constants, roots)])
+ homogen_sol = Eq(f(x), homogen_sol)
+ homogen_sol = _solve_variation_of_parameters(eq, f(x), roots, homogen_sol, order, self.r, simplify_flag)
+ if simplify_flag:
+ homogen_sol = _get_simplified_sol([homogen_sol], f(x), collectterms)
+ return [homogen_sol]
+
+
+class NthLinearConstantCoeffUndeterminedCoefficients(SingleODESolver):
+ r"""
+ Solves an `n`\th order linear differential equation with constant
+ coefficients using the method of undetermined coefficients.
+
+ This method works on differential equations of the form
+
+ .. math:: a_n f^{(n)}(x) + a_{n-1} f^{(n-1)}(x) + \cdots + a_1 f'(x)
+ + a_0 f(x) = P(x)\text{,}
+
+ where `P(x)` is a function that has a finite number of linearly
+ independent derivatives.
+
+ Functions that fit this requirement are finite sums functions of the form
+ `a x^i e^{b x} \sin(c x + d)` or `a x^i e^{b x} \cos(c x + d)`, where `i`
+ is a non-negative integer and `a`, `b`, `c`, and `d` are constants. For
+ example any polynomial in `x`, functions like `x^2 e^{2 x}`, `x \sin(x)`,
+ and `e^x \cos(x)` can all be used. Products of `\sin`'s and `\cos`'s have
+ a finite number of derivatives, because they can be expanded into `\sin(a
+ x)` and `\cos(b x)` terms. However, SymPy currently cannot do that
+ expansion, so you will need to manually rewrite the expression in terms of
+ the above to use this method. So, for example, you will need to manually
+ convert `\sin^2(x)` into `(1 + \cos(2 x))/2` to properly apply the method
+ of undetermined coefficients on it.
+
+ This method works by creating a trial function from the expression and all
+ of its linear independent derivatives and substituting them into the
+ original ODE. The coefficients for each term will be a system of linear
+ equations, which are be solved for and substituted, giving the solution.
+ If any of the trial functions are linearly dependent on the solution to
+ the homogeneous equation, they are multiplied by sufficient `x` to make
+ them linearly independent.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, pprint, exp, cos
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> pprint(dsolve(f(x).diff(x, 2) + 2*f(x).diff(x) + f(x) -
+ ... 4*exp(-x)*x**2 + cos(2*x), f(x),
+ ... hint='nth_linear_constant_coeff_undetermined_coefficients'))
+ / / 3\\
+ | | x || -x 4*sin(2*x) 3*cos(2*x)
+ f(x) = |C1 + x*|C2 + --||*e - ---------- + ----------
+ \ \ 3 // 25 25
+
+ References
+ ==========
+
+ - https://en.wikipedia.org/wiki/Method_of_undetermined_coefficients
+ - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+ Dover 1963, pp. 221
+
+ # indirect doctest
+
+ """
+ hint = "nth_linear_constant_coeff_undetermined_coefficients"
+ has_integral = False
+
+ def _matches(self):
+ eq = self.ode_problem.eq_high_order_free
+ func = self.ode_problem.func
+ order = self.ode_problem.order
+ x = self.ode_problem.sym
+ self.r = self.ode_problem.get_linear_coefficients(eq, func, order)
+ does_match = False
+ if order and self.r and not any(self.r[i].has(x) for i in self.r if i >= 0):
+ if self.r[-1]:
+ eq_homogeneous = Add(eq, -self.r[-1])
+ undetcoeff = _undetermined_coefficients_match(self.r[-1], x, func, eq_homogeneous)
+ if undetcoeff['test']:
+ self.trialset = undetcoeff['trialset']
+ does_match = True
+ return does_match
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ eq = self.ode_problem.eq
+ f = self.ode_problem.func.func
+ x = self.ode_problem.sym
+ order = self.ode_problem.order
+ roots, collectterms = _get_const_characteristic_eq_sols(self.r, f(x), order)
+ # A generator of constants
+ constants = self.ode_problem.get_numbered_constants(num=len(roots))
+ homogen_sol = Add(*[i*j for (i, j) in zip(constants, roots)])
+ homogen_sol = Eq(f(x), homogen_sol)
+ self.r.update({'list': roots, 'sol': homogen_sol, 'simpliy_flag': simplify_flag})
+ gsol = _solve_undetermined_coefficients(eq, f(x), order, self.r, self.trialset)
+ if simplify_flag:
+ gsol = _get_simplified_sol([gsol], f(x), collectterms)
+ return [gsol]
+
+
+class NthLinearEulerEqHomogeneous(SingleODESolver):
+ r"""
+ Solves an `n`\th order linear homogeneous variable-coefficient
+ Cauchy-Euler equidimensional ordinary differential equation.
+
+ This is an equation with form `0 = a_0 f(x) + a_1 x f'(x) + a_2 x^2 f''(x)
+ \cdots`.
+
+ These equations can be solved in a general manner, by substituting
+ solutions of the form `f(x) = x^r`, and deriving a characteristic equation
+ for `r`. When there are repeated roots, we include extra terms of the
+ form `C_{r k} \ln^k(x) x^r`, where `C_{r k}` is an arbitrary integration
+ constant, `r` is a root of the characteristic equation, and `k` ranges
+ over the multiplicity of `r`. In the cases where the roots are complex,
+ solutions of the form `C_1 x^a \sin(b \log(x)) + C_2 x^a \cos(b \log(x))`
+ are returned, based on expansions with Euler's formula. The general
+ solution is the sum of the terms found. If SymPy cannot find exact roots
+ to the characteristic equation, a
+ :py:obj:`~.ComplexRootOf` instance will be returned
+ instead.
+
+ >>> from sympy import Function, dsolve
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> dsolve(4*x**2*f(x).diff(x, 2) + f(x), f(x),
+ ... hint='nth_linear_euler_eq_homogeneous')
+ ... # doctest: +NORMALIZE_WHITESPACE
+ Eq(f(x), sqrt(x)*(C1 + C2*log(x)))
+
+ Note that because this method does not involve integration, there is no
+ ``nth_linear_euler_eq_homogeneous_Integral`` hint.
+
+ The following is for internal use:
+
+ - ``returns = 'sol'`` returns the solution to the ODE.
+ - ``returns = 'list'`` returns a list of linearly independent solutions,
+ corresponding to the fundamental solution set, for use with non
+ homogeneous solution methods like variation of parameters and
+ undetermined coefficients. Note that, though the solutions should be
+ linearly independent, this function does not explicitly check that. You
+ can do ``assert simplify(wronskian(sollist)) != 0`` to check for linear
+ independence. Also, ``assert len(sollist) == order`` will need to pass.
+ - ``returns = 'both'``, return a dictionary ``{'sol': ,
+ 'list': }``.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, pprint
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> eq = f(x).diff(x, 2)*x**2 - 4*f(x).diff(x)*x + 6*f(x)
+ >>> pprint(dsolve(eq, f(x),
+ ... hint='nth_linear_euler_eq_homogeneous'))
+ 2
+ f(x) = x *(C1 + C2*x)
+
+ References
+ ==========
+
+ - https://en.wikipedia.org/wiki/Cauchy%E2%80%93Euler_equation
+ - C. Bender & S. Orszag, "Advanced Mathematical Methods for Scientists and
+ Engineers", Springer 1999, pp. 12
+
+ # indirect doctest
+
+ """
+ hint = "nth_linear_euler_eq_homogeneous"
+ has_integral = False
+
+ def _matches(self):
+ eq = self.ode_problem.eq_preprocessed
+ f = self.ode_problem.func.func
+ order = self.ode_problem.order
+ x = self.ode_problem.sym
+ match = self.ode_problem.get_linear_coefficients(eq, f(x), order)
+ self.r = None
+ does_match = False
+
+ if order and match:
+ coeff = match[order]
+ factor = x**order / coeff
+ self.r = {i: factor*match[i] for i in match}
+ if self.r and all(_test_term(self.r[i], f(x), i) for i in
+ self.r if i >= 0):
+ if not self.r[-1]:
+ does_match = True
+ return does_match
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ fx = self.ode_problem.func
+ eq = self.ode_problem.eq
+ homogen_sol = _get_euler_characteristic_eq_sols(eq, fx, self.r)[0]
+ return [homogen_sol]
+
+
+class NthLinearEulerEqNonhomogeneousVariationOfParameters(SingleODESolver):
+ r"""
+ Solves an `n`\th order linear non homogeneous Cauchy-Euler equidimensional
+ ordinary differential equation using variation of parameters.
+
+ This is an equation with form `g(x) = a_0 f(x) + a_1 x f'(x) + a_2 x^2 f''(x)
+ \cdots`.
+
+ This method works by assuming that the particular solution takes the form
+
+ .. math:: \sum_{x=1}^{n} c_i(x) y_i(x) {a_n} {x^n} \text{, }
+
+ where `y_i` is the `i`\th solution to the homogeneous equation. The
+ solution is then solved using Wronskian's and Cramer's Rule. The
+ particular solution is given by multiplying eq given below with `a_n x^{n}`
+
+ .. math:: \sum_{x=1}^n \left( \int \frac{W_i(x)}{W(x)} \, dx
+ \right) y_i(x) \text{, }
+
+ where `W(x)` is the Wronskian of the fundamental system (the system of `n`
+ linearly independent solutions to the homogeneous equation), and `W_i(x)`
+ is the Wronskian of the fundamental system with the `i`\th column replaced
+ with `[0, 0, \cdots, 0, \frac{x^{- n}}{a_n} g{\left(x \right)}]`.
+
+ This method is general enough to solve any `n`\th order inhomogeneous
+ linear differential equation, but sometimes SymPy cannot simplify the
+ Wronskian well enough to integrate it. If this method hangs, try using the
+ ``nth_linear_constant_coeff_variation_of_parameters_Integral`` hint and
+ simplifying the integrals manually. Also, prefer using
+ ``nth_linear_constant_coeff_undetermined_coefficients`` when it
+ applies, because it does not use integration, making it faster and more
+ reliable.
+
+ Warning, using simplify=False with
+ 'nth_linear_constant_coeff_variation_of_parameters' in
+ :py:meth:`~sympy.solvers.ode.dsolve` may cause it to hang, because it will
+ not attempt to simplify the Wronskian before integrating. It is
+ recommended that you only use simplify=False with
+ 'nth_linear_constant_coeff_variation_of_parameters_Integral' for this
+ method, especially if the solution to the homogeneous equation has
+ trigonometric functions in it.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, Derivative
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> eq = x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x) - x**4
+ >>> dsolve(eq, f(x),
+ ... hint='nth_linear_euler_eq_nonhomogeneous_variation_of_parameters').expand()
+ Eq(f(x), C1*x + C2*x**2 + x**4/6)
+
+ """
+ hint = "nth_linear_euler_eq_nonhomogeneous_variation_of_parameters"
+ has_integral = True
+
+ def _matches(self):
+ eq = self.ode_problem.eq_preprocessed
+ f = self.ode_problem.func.func
+ order = self.ode_problem.order
+ x = self.ode_problem.sym
+ match = self.ode_problem.get_linear_coefficients(eq, f(x), order)
+ self.r = None
+ does_match = False
+
+ if order and match:
+ coeff = match[order]
+ factor = x**order / coeff
+ self.r = {i: factor*match[i] for i in match}
+ if self.r and all(_test_term(self.r[i], f(x), i) for i in
+ self.r if i >= 0):
+ if self.r[-1]:
+ does_match = True
+
+ return does_match
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ eq = self.ode_problem.eq
+ f = self.ode_problem.func.func
+ x = self.ode_problem.sym
+ order = self.ode_problem.order
+ homogen_sol, roots = _get_euler_characteristic_eq_sols(eq, f(x), self.r)
+ self.r[-1] = self.r[-1]/self.r[order]
+ sol = _solve_variation_of_parameters(eq, f(x), roots, homogen_sol, order, self.r, simplify_flag)
+
+ return [Eq(f(x), homogen_sol.rhs + (sol.rhs - homogen_sol.rhs)*self.r[order])]
+
+
+class NthLinearEulerEqNonhomogeneousUndeterminedCoefficients(SingleODESolver):
+ r"""
+ Solves an `n`\th order linear non homogeneous Cauchy-Euler equidimensional
+ ordinary differential equation using undetermined coefficients.
+
+ This is an equation with form `g(x) = a_0 f(x) + a_1 x f'(x) + a_2 x^2 f''(x)
+ \cdots`.
+
+ These equations can be solved in a general manner, by substituting
+ solutions of the form `x = exp(t)`, and deriving a characteristic equation
+ of form `g(exp(t)) = b_0 f(t) + b_1 f'(t) + b_2 f''(t) \cdots` which can
+ be then solved by nth_linear_constant_coeff_undetermined_coefficients if
+ g(exp(t)) has finite number of linearly independent derivatives.
+
+ Functions that fit this requirement are finite sums functions of the form
+ `a x^i e^{b x} \sin(c x + d)` or `a x^i e^{b x} \cos(c x + d)`, where `i`
+ is a non-negative integer and `a`, `b`, `c`, and `d` are constants. For
+ example any polynomial in `x`, functions like `x^2 e^{2 x}`, `x \sin(x)`,
+ and `e^x \cos(x)` can all be used. Products of `\sin`'s and `\cos`'s have
+ a finite number of derivatives, because they can be expanded into `\sin(a
+ x)` and `\cos(b x)` terms. However, SymPy currently cannot do that
+ expansion, so you will need to manually rewrite the expression in terms of
+ the above to use this method. So, for example, you will need to manually
+ convert `\sin^2(x)` into `(1 + \cos(2 x))/2` to properly apply the method
+ of undetermined coefficients on it.
+
+ After replacement of x by exp(t), this method works by creating a trial function
+ from the expression and all of its linear independent derivatives and
+ substituting them into the original ODE. The coefficients for each term
+ will be a system of linear equations, which are be solved for and
+ substituted, giving the solution. If any of the trial functions are linearly
+ dependent on the solution to the homogeneous equation, they are multiplied
+ by sufficient `x` to make them linearly independent.
+
+ Examples
+ ========
+
+ >>> from sympy import dsolve, Function, Derivative, log
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> eq = x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x) - log(x)
+ >>> dsolve(eq, f(x),
+ ... hint='nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients').expand()
+ Eq(f(x), C1*x + C2*x**2 + log(x)/2 + 3/4)
+
+ """
+ hint = "nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients"
+ has_integral = False
+
+ def _matches(self):
+ eq = self.ode_problem.eq_high_order_free
+ f = self.ode_problem.func.func
+ order = self.ode_problem.order
+ x = self.ode_problem.sym
+ match = self.ode_problem.get_linear_coefficients(eq, f(x), order)
+ self.r = None
+ does_match = False
+
+ if order and match:
+ coeff = match[order]
+ factor = x**order / coeff
+ self.r = {i: factor*match[i] for i in match}
+ if self.r and all(_test_term(self.r[i], f(x), i) for i in
+ self.r if i >= 0):
+ if self.r[-1]:
+ e, re = posify(self.r[-1].subs(x, exp(x)))
+ undetcoeff = _undetermined_coefficients_match(e.subs(re), x)
+ if undetcoeff['test']:
+ does_match = True
+ return does_match
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ f = self.ode_problem.func.func
+ x = self.ode_problem.sym
+ chareq, eq, symbol = S.Zero, S.Zero, Dummy('x')
+ for i in self.r.keys():
+ if i >= 0:
+ chareq += (self.r[i]*diff(x**symbol, x, i)*x**-symbol).expand()
+
+ for i in range(1, degree(Poly(chareq, symbol))+1):
+ eq += chareq.coeff(symbol**i)*diff(f(x), x, i)
+
+ if chareq.as_coeff_add(symbol)[0]:
+ eq += chareq.as_coeff_add(symbol)[0]*f(x)
+ e, re = posify(self.r[-1].subs(x, exp(x)))
+ eq += e.subs(re)
+
+ self.const_undet_instance = NthLinearConstantCoeffUndeterminedCoefficients(SingleODEProblem(eq, f(x), x))
+ sol = self.const_undet_instance.get_general_solution(simplify = simplify_flag)[0]
+ sol = sol.subs(x, log(x))
+ sol = sol.subs(f(log(x)), f(x)).expand()
+
+ return [sol]
+
+
+class SecondLinearBessel(SingleODESolver):
+ r"""
+ Gives solution of the Bessel differential equation
+
+ .. math :: x^2 \frac{d^2y}{dx^2} + x \frac{dy}{dx} y(x) + (x^2-n^2) y(x)
+
+ if `n` is integer then the solution is of the form ``Eq(f(x), C0 besselj(n,x)
+ + C1 bessely(n,x))`` as both the solutions are linearly independent else if
+ `n` is a fraction then the solution is of the form ``Eq(f(x), C0 besselj(n,x)
+ + C1 besselj(-n,x))`` which can also transform into ``Eq(f(x), C0 besselj(n,x)
+ + C1 bessely(n,x))``.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import x
+ >>> from sympy import Symbol
+ >>> v = Symbol('v', positive=True)
+ >>> from sympy import dsolve, Function
+ >>> f = Function('f')
+ >>> y = f(x)
+ >>> genform = x**2*y.diff(x, 2) + x*y.diff(x) + (x**2 - v**2)*y
+ >>> dsolve(genform)
+ Eq(f(x), C1*besselj(v, x) + C2*bessely(v, x))
+
+ References
+ ==========
+
+ https://math24.net/bessel-differential-equation.html
+
+ """
+ hint = "2nd_linear_bessel"
+ has_integral = False
+
+ def _matches(self):
+ eq = self.ode_problem.eq_high_order_free
+ f = self.ode_problem.func
+ order = self.ode_problem.order
+ x = self.ode_problem.sym
+ df = f.diff(x)
+ a = Wild('a', exclude=[f,df])
+ b = Wild('b', exclude=[x, f,df])
+ a4 = Wild('a4', exclude=[x,f,df])
+ b4 = Wild('b4', exclude=[x,f,df])
+ c4 = Wild('c4', exclude=[x,f,df])
+ d4 = Wild('d4', exclude=[x,f,df])
+ a3 = Wild('a3', exclude=[f, df, f.diff(x, 2)])
+ b3 = Wild('b3', exclude=[f, df, f.diff(x, 2)])
+ c3 = Wild('c3', exclude=[f, df, f.diff(x, 2)])
+ deq = a3*(f.diff(x, 2)) + b3*df + c3*f
+ r = collect(eq,
+ [f.diff(x, 2), df, f]).match(deq)
+ if order == 2 and r:
+ if not all(r[key].is_polynomial() for key in r):
+ n, d = eq.as_numer_denom()
+ eq = expand(n)
+ r = collect(eq,
+ [f.diff(x, 2), df, f]).match(deq)
+
+ if r and r[a3] != 0:
+ # leading coeff of f(x).diff(x, 2)
+ coeff = factor(r[a3]).match(a4*(x-b)**b4)
+
+ if coeff:
+ # if coeff[b4] = 0 means constant coefficient
+ if coeff[b4] == 0:
+ return False
+ point = coeff[b]
+ else:
+ return False
+
+ if point:
+ r[a3] = simplify(r[a3].subs(x, x+point))
+ r[b3] = simplify(r[b3].subs(x, x+point))
+ r[c3] = simplify(r[c3].subs(x, x+point))
+
+ # making a3 in the form of x**2
+ r[a3] = cancel(r[a3]/(coeff[a4]*(x)**(-2+coeff[b4])))
+ r[b3] = cancel(r[b3]/(coeff[a4]*(x)**(-2+coeff[b4])))
+ r[c3] = cancel(r[c3]/(coeff[a4]*(x)**(-2+coeff[b4])))
+ # checking if b3 is of form c*(x-b)
+ coeff1 = factor(r[b3]).match(a4*(x))
+ if coeff1 is None:
+ return False
+ # c3 maybe of very complex form so I am simply checking (a - b) form
+ # if yes later I will match with the standerd form of bessel in a and b
+ # a, b are wild variable defined above.
+ _coeff2 = r[c3].match(a - b)
+ if _coeff2 is None:
+ return False
+ # matching with standerd form for c3
+ coeff2 = factor(_coeff2[a]).match(c4**2*(x)**(2*a4))
+ if coeff2 is None:
+ return False
+
+ if _coeff2[b] == 0:
+ coeff2[d4] = 0
+ else:
+ coeff2[d4] = factor(_coeff2[b]).match(d4**2)[d4]
+
+ self.rn = {'n':coeff2[d4], 'a4':coeff2[c4], 'd4':coeff2[a4]}
+ self.rn['c4'] = coeff1[a4]
+ self.rn['b4'] = point
+ return True
+ return False
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ f = self.ode_problem.func.func
+ x = self.ode_problem.sym
+ n = self.rn['n']
+ a4 = self.rn['a4']
+ c4 = self.rn['c4']
+ d4 = self.rn['d4']
+ b4 = self.rn['b4']
+ n = sqrt(n**2 + Rational(1, 4)*(c4 - 1)**2)
+ (C1, C2) = self.ode_problem.get_numbered_constants(num=2)
+ return [Eq(f(x), ((x**(Rational(1-c4,2)))*(C1*besselj(n/d4,a4*x**d4/d4)
+ + C2*bessely(n/d4,a4*x**d4/d4))).subs(x, x-b4))]
+
+
+class SecondLinearAiry(SingleODESolver):
+ r"""
+ Gives solution of the Airy differential equation
+
+ .. math :: \frac{d^2y}{dx^2} + (a + b x) y(x) = 0
+
+ in terms of Airy special functions airyai and airybi.
+
+ Examples
+ ========
+
+ >>> from sympy import dsolve, Function
+ >>> from sympy.abc import x
+ >>> f = Function("f")
+ >>> eq = f(x).diff(x, 2) - x*f(x)
+ >>> dsolve(eq)
+ Eq(f(x), C1*airyai(x) + C2*airybi(x))
+ """
+ hint = "2nd_linear_airy"
+ has_integral = False
+
+ def _matches(self):
+ eq = self.ode_problem.eq_high_order_free
+ f = self.ode_problem.func
+ order = self.ode_problem.order
+ x = self.ode_problem.sym
+ df = f.diff(x)
+ a4 = Wild('a4', exclude=[x,f,df])
+ b4 = Wild('b4', exclude=[x,f,df])
+ match = self.ode_problem.get_linear_coefficients(eq, f, order)
+ does_match = False
+ if order == 2 and match and match[2] != 0:
+ if match[1].is_zero:
+ self.rn = cancel(match[0]/match[2]).match(a4+b4*x)
+ if self.rn and self.rn[b4] != 0:
+ self.rn = {'b':self.rn[a4],'m':self.rn[b4]}
+ does_match = True
+ return does_match
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ f = self.ode_problem.func.func
+ x = self.ode_problem.sym
+ (C1, C2) = self.ode_problem.get_numbered_constants(num=2)
+ b = self.rn['b']
+ m = self.rn['m']
+ if m.is_positive:
+ arg = - b/cbrt(m)**2 - cbrt(m)*x
+ elif m.is_negative:
+ arg = - b/cbrt(-m)**2 + cbrt(-m)*x
+ else:
+ arg = - b/cbrt(-m)**2 + cbrt(-m)*x
+
+ return [Eq(f(x), C1*airyai(arg) + C2*airybi(arg))]
+
+
+class LieGroup(SingleODESolver):
+ r"""
+ This hint implements the Lie group method of solving first order differential
+ equations. The aim is to convert the given differential equation from the
+ given coordinate system into another coordinate system where it becomes
+ invariant under the one-parameter Lie group of translations. The converted
+ ODE can be easily solved by quadrature. It makes use of the
+ :py:meth:`sympy.solvers.ode.infinitesimals` function which returns the
+ infinitesimals of the transformation.
+
+ The coordinates `r` and `s` can be found by solving the following Partial
+ Differential Equations.
+
+ .. math :: \xi\frac{\partial r}{\partial x} + \eta\frac{\partial r}{\partial y}
+ = 0
+
+ .. math :: \xi\frac{\partial s}{\partial x} + \eta\frac{\partial s}{\partial y}
+ = 1
+
+ The differential equation becomes separable in the new coordinate system
+
+ .. math :: \frac{ds}{dr} = \frac{\frac{\partial s}{\partial x} +
+ h(x, y)\frac{\partial s}{\partial y}}{
+ \frac{\partial r}{\partial x} + h(x, y)\frac{\partial r}{\partial y}}
+
+ After finding the solution by integration, it is then converted back to the original
+ coordinate system by substituting `r` and `s` in terms of `x` and `y` again.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, dsolve, exp, pprint
+ >>> from sympy.abc import x
+ >>> f = Function('f')
+ >>> pprint(dsolve(f(x).diff(x) + 2*x*f(x) - x*exp(-x**2), f(x),
+ ... hint='lie_group'))
+ / 2\ 2
+ | x | -x
+ f(x) = |C1 + --|*e
+ \ 2 /
+
+
+ References
+ ==========
+
+ - Solving differential equations by Symmetry Groups,
+ John Starrett, pp. 1 - pp. 14
+
+ """
+ hint = "lie_group"
+ has_integral = False
+
+ def _has_additional_params(self):
+ return 'xi' in self.ode_problem.params and 'eta' in self.ode_problem.params
+
+ def _matches(self):
+ eq = self.ode_problem.eq
+ f = self.ode_problem.func.func
+ order = self.ode_problem.order
+ x = self.ode_problem.sym
+ df = f(x).diff(x)
+ y = Dummy('y')
+ d = Wild('d', exclude=[df, f(x).diff(x, 2)])
+ e = Wild('e', exclude=[df])
+ does_match = False
+ if self._has_additional_params() and order == 1:
+ xi = self.ode_problem.params['xi']
+ eta = self.ode_problem.params['eta']
+ self.r3 = {'xi': xi, 'eta': eta}
+ r = collect(eq, df, exact=True).match(d + e * df)
+ if r:
+ r['d'] = d
+ r['e'] = e
+ r['y'] = y
+ r[d] = r[d].subs(f(x), y)
+ r[e] = r[e].subs(f(x), y)
+ self.r3.update(r)
+ does_match = True
+ return does_match
+
+ def _get_general_solution(self, *, simplify_flag: bool = True):
+ eq = self.ode_problem.eq
+ x = self.ode_problem.sym
+ func = self.ode_problem.func
+ order = self.ode_problem.order
+ df = func.diff(x)
+
+ try:
+ eqsol = solve(eq, df)
+ except NotImplementedError:
+ eqsol = []
+
+ desols = []
+ for s in eqsol:
+ sol = _ode_lie_group(s, func, order, match=self.r3)
+ if sol:
+ desols.extend(sol)
+
+ if desols == []:
+ raise NotImplementedError("The given ODE " + str(eq) + " cannot be solved by"
+ + " the lie group method")
+ return desols
+
+
+solver_map = {
+ 'factorable': Factorable,
+ 'nth_linear_constant_coeff_homogeneous': NthLinearConstantCoeffHomogeneous,
+ 'nth_linear_euler_eq_homogeneous': NthLinearEulerEqHomogeneous,
+ 'nth_linear_constant_coeff_undetermined_coefficients': NthLinearConstantCoeffUndeterminedCoefficients,
+ 'nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients': NthLinearEulerEqNonhomogeneousUndeterminedCoefficients,
+ 'separable': Separable,
+ '1st_exact': FirstExact,
+ '1st_linear': FirstLinear,
+ 'Bernoulli': Bernoulli,
+ 'Riccati_special_minus2': RiccatiSpecial,
+ '1st_rational_riccati': RationalRiccati,
+ '1st_homogeneous_coeff_best': HomogeneousCoeffBest,
+ '1st_homogeneous_coeff_subs_indep_div_dep': HomogeneousCoeffSubsIndepDivDep,
+ '1st_homogeneous_coeff_subs_dep_div_indep': HomogeneousCoeffSubsDepDivIndep,
+ 'almost_linear': AlmostLinear,
+ 'linear_coefficients': LinearCoefficients,
+ 'separable_reduced': SeparableReduced,
+ 'nth_linear_constant_coeff_variation_of_parameters': NthLinearConstantCoeffVariationOfParameters,
+ 'nth_linear_euler_eq_nonhomogeneous_variation_of_parameters': NthLinearEulerEqNonhomogeneousVariationOfParameters,
+ 'Liouville': Liouville,
+ '2nd_linear_airy': SecondLinearAiry,
+ '2nd_linear_bessel': SecondLinearBessel,
+ '2nd_hypergeometric': SecondHypergeometric,
+ 'nth_order_reducible': NthOrderReducible,
+ '2nd_nonlinear_autonomous_conserved': SecondNonlinearAutonomousConserved,
+ 'nth_algebraic': NthAlgebraic,
+ 'lie_group': LieGroup,
+ }
+
+# Avoid circular import:
+from .ode import dsolve, ode_sol_simplicity, odesimp, homogeneous_order
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/subscheck.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/subscheck.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ac7fba7d364bf599e928ccf591b5bef096576d0
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/subscheck.py
@@ -0,0 +1,392 @@
+from sympy.core import S, Pow
+from sympy.core.function import (Derivative, AppliedUndef, diff)
+from sympy.core.relational import Equality, Eq
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+
+from sympy.logic.boolalg import BooleanAtom
+from sympy.functions import exp
+from sympy.series import Order
+from sympy.simplify.simplify import simplify, posify, besselsimp
+from sympy.simplify.trigsimp import trigsimp
+from sympy.simplify.sqrtdenest import sqrtdenest
+from sympy.solvers import solve
+from sympy.solvers.deutils import _preprocess, ode_order
+from sympy.utilities.iterables import iterable, is_sequence
+
+
+def sub_func_doit(eq, func, new):
+ r"""
+ When replacing the func with something else, we usually want the
+ derivative evaluated, so this function helps in making that happen.
+
+ Examples
+ ========
+
+ >>> from sympy import Derivative, symbols, Function
+ >>> from sympy.solvers.ode.subscheck import sub_func_doit
+ >>> x, z = symbols('x, z')
+ >>> y = Function('y')
+
+ >>> sub_func_doit(3*Derivative(y(x), x) - 1, y(x), x)
+ 2
+
+ >>> sub_func_doit(x*Derivative(y(x), x) - y(x)**2 + y(x), y(x),
+ ... 1/(x*(z + 1/x)))
+ x*(-1/(x**2*(z + 1/x)) + 1/(x**3*(z + 1/x)**2)) + 1/(x*(z + 1/x))
+ ...- 1/(x**2*(z + 1/x)**2)
+ """
+ reps= {func: new}
+ for d in eq.atoms(Derivative):
+ if d.expr == func:
+ reps[d] = new.diff(*d.variable_count)
+ else:
+ reps[d] = d.xreplace({func: new}).doit(deep=False)
+ return eq.xreplace(reps)
+
+
+def checkodesol(ode, sol, func=None, order='auto', solve_for_func=True):
+ r"""
+ Substitutes ``sol`` into ``ode`` and checks that the result is ``0``.
+
+ This works when ``func`` is one function, like `f(x)` or a list of
+ functions like `[f(x), g(x)]` when `ode` is a system of ODEs. ``sol`` can
+ be a single solution or a list of solutions. Each solution may be an
+ :py:class:`~sympy.core.relational.Equality` that the solution satisfies,
+ e.g. ``Eq(f(x), C1), Eq(f(x) + C1, 0)``; or simply an
+ :py:class:`~sympy.core.expr.Expr`, e.g. ``f(x) - C1``. In most cases it
+ will not be necessary to explicitly identify the function, but if the
+ function cannot be inferred from the original equation it can be supplied
+ through the ``func`` argument.
+
+ If a sequence of solutions is passed, the same sort of container will be
+ used to return the result for each solution.
+
+ It tries the following methods, in order, until it finds zero equivalence:
+
+ 1. Substitute the solution for `f` in the original equation. This only
+ works if ``ode`` is solved for `f`. It will attempt to solve it first
+ unless ``solve_for_func == False``.
+ 2. Take `n` derivatives of the solution, where `n` is the order of
+ ``ode``, and check to see if that is equal to the solution. This only
+ works on exact ODEs.
+ 3. Take the 1st, 2nd, ..., `n`\th derivatives of the solution, each time
+ solving for the derivative of `f` of that order (this will always be
+ possible because `f` is a linear operator). Then back substitute each
+ derivative into ``ode`` in reverse order.
+
+ This function returns a tuple. The first item in the tuple is ``True`` if
+ the substitution results in ``0``, and ``False`` otherwise. The second
+ item in the tuple is what the substitution results in. It should always
+ be ``0`` if the first item is ``True``. Sometimes this function will
+ return ``False`` even when an expression is identically equal to ``0``.
+ This happens when :py:meth:`~sympy.simplify.simplify.simplify` does not
+ reduce the expression to ``0``. If an expression returned by this
+ function vanishes identically, then ``sol`` really is a solution to
+ the ``ode``.
+
+ If this function seems to hang, it is probably because of a hard
+ simplification.
+
+ To use this function to test, test the first item of the tuple.
+
+ Examples
+ ========
+
+ >>> from sympy import (Eq, Function, checkodesol, symbols,
+ ... Derivative, exp)
+ >>> x, C1, C2 = symbols('x,C1,C2')
+ >>> f, g = symbols('f g', cls=Function)
+ >>> checkodesol(f(x).diff(x), Eq(f(x), C1))
+ (True, 0)
+ >>> assert checkodesol(f(x).diff(x), C1)[0]
+ >>> assert not checkodesol(f(x).diff(x), x)[0]
+ >>> checkodesol(f(x).diff(x, 2), x**2)
+ (False, 2)
+
+ >>> eqs = [Eq(Derivative(f(x), x), f(x)), Eq(Derivative(g(x), x), g(x))]
+ >>> sol = [Eq(f(x), C1*exp(x)), Eq(g(x), C2*exp(x))]
+ >>> checkodesol(eqs, sol)
+ (True, [0, 0])
+
+ """
+ if iterable(ode):
+ return checksysodesol(ode, sol, func=func)
+
+ if not isinstance(ode, Equality):
+ ode = Eq(ode, 0)
+ if func is None:
+ try:
+ _, func = _preprocess(ode.lhs)
+ except ValueError:
+ funcs = [s.atoms(AppliedUndef) for s in (
+ sol if is_sequence(sol, set) else [sol])]
+ funcs = set().union(*funcs)
+ if len(funcs) != 1:
+ raise ValueError(
+ 'must pass func arg to checkodesol for this case.')
+ func = funcs.pop()
+ if not isinstance(func, AppliedUndef) or len(func.args) != 1:
+ raise ValueError(
+ "func must be a function of one variable, not %s" % func)
+ if is_sequence(sol, set):
+ return type(sol)([checkodesol(ode, i, order=order, solve_for_func=solve_for_func) for i in sol])
+
+ if not isinstance(sol, Equality):
+ sol = Eq(func, sol)
+ elif sol.rhs == func:
+ sol = sol.reversed
+
+ if order == 'auto':
+ order = ode_order(ode, func)
+ solved = sol.lhs == func and not sol.rhs.has(func)
+ if solve_for_func and not solved:
+ rhs = solve(sol, func)
+ if rhs:
+ eqs = [Eq(func, t) for t in rhs]
+ if len(rhs) == 1:
+ eqs = eqs[0]
+ return checkodesol(ode, eqs, order=order,
+ solve_for_func=False)
+
+ x = func.args[0]
+
+ # Handle series solutions here
+ if sol.has(Order):
+ assert sol.lhs == func
+ Oterm = sol.rhs.getO()
+ solrhs = sol.rhs.removeO()
+
+ Oexpr = Oterm.expr
+ assert isinstance(Oexpr, Pow)
+ sorder = Oexpr.exp
+ assert Oterm == Order(x**sorder)
+
+ odesubs = (ode.lhs-ode.rhs).subs(func, solrhs).doit().expand()
+
+ neworder = Order(x**(sorder - order))
+ odesubs = odesubs + neworder
+ assert odesubs.getO() == neworder
+ residual = odesubs.removeO()
+
+ return (residual == 0, residual)
+
+ s = True
+ testnum = 0
+ while s:
+ if testnum == 0:
+ # First pass, try substituting a solved solution directly into the
+ # ODE. This has the highest chance of succeeding.
+ ode_diff = ode.lhs - ode.rhs
+
+ if sol.lhs == func:
+ s = sub_func_doit(ode_diff, func, sol.rhs)
+ s = besselsimp(s)
+ else:
+ testnum += 1
+ continue
+ ss = simplify(s.rewrite(exp))
+ if ss:
+ # with the new numer_denom in power.py, if we do a simple
+ # expansion then testnum == 0 verifies all solutions.
+ s = ss.expand(force=True)
+ else:
+ s = 0
+ testnum += 1
+ elif testnum == 1:
+ # Second pass. If we cannot substitute f, try seeing if the nth
+ # derivative is equal, this will only work for odes that are exact,
+ # by definition.
+ s = simplify(
+ trigsimp(diff(sol.lhs, x, order) - diff(sol.rhs, x, order)) -
+ trigsimp(ode.lhs) + trigsimp(ode.rhs))
+ # s2 = simplify(
+ # diff(sol.lhs, x, order) - diff(sol.rhs, x, order) - \
+ # ode.lhs + ode.rhs)
+ testnum += 1
+ elif testnum == 2:
+ # Third pass. Try solving for df/dx and substituting that into the
+ # ODE. Thanks to Chris Smith for suggesting this method. Many of
+ # the comments below are his, too.
+ # The method:
+ # - Take each of 1..n derivatives of the solution.
+ # - Solve each nth derivative for d^(n)f/dx^(n)
+ # (the differential of that order)
+ # - Back substitute into the ODE in decreasing order
+ # (i.e., n, n-1, ...)
+ # - Check the result for zero equivalence
+ if sol.lhs == func and not sol.rhs.has(func):
+ diffsols = {0: sol.rhs}
+ elif sol.rhs == func and not sol.lhs.has(func):
+ diffsols = {0: sol.lhs}
+ else:
+ diffsols = {}
+ sol = sol.lhs - sol.rhs
+ for i in range(1, order + 1):
+ # Differentiation is a linear operator, so there should always
+ # be 1 solution. Nonetheless, we test just to make sure.
+ # We only need to solve once. After that, we automatically
+ # have the solution to the differential in the order we want.
+ if i == 1:
+ ds = sol.diff(x)
+ try:
+ sdf = solve(ds, func.diff(x, i))
+ if not sdf:
+ raise NotImplementedError
+ except NotImplementedError:
+ testnum += 1
+ break
+ else:
+ diffsols[i] = sdf[0]
+ else:
+ # This is what the solution says df/dx should be.
+ diffsols[i] = diffsols[i - 1].diff(x)
+
+ # Make sure the above didn't fail.
+ if testnum > 2:
+ continue
+ else:
+ # Substitute it into ODE to check for self consistency.
+ lhs, rhs = ode.lhs, ode.rhs
+ for i in range(order, -1, -1):
+ if i == 0 and 0 not in diffsols:
+ # We can only substitute f(x) if the solution was
+ # solved for f(x).
+ break
+ lhs = sub_func_doit(lhs, func.diff(x, i), diffsols[i])
+ rhs = sub_func_doit(rhs, func.diff(x, i), diffsols[i])
+ ode_or_bool = Eq(lhs, rhs)
+ ode_or_bool = simplify(ode_or_bool)
+
+ if isinstance(ode_or_bool, (bool, BooleanAtom)):
+ if ode_or_bool:
+ lhs = rhs = S.Zero
+ else:
+ lhs = ode_or_bool.lhs
+ rhs = ode_or_bool.rhs
+ # No sense in overworking simplify -- just prove that the
+ # numerator goes to zero
+ num = trigsimp((lhs - rhs).as_numer_denom()[0])
+ # since solutions are obtained using force=True we test
+ # using the same level of assumptions
+ ## replace function with dummy so assumptions will work
+ _func = Dummy('func')
+ num = num.subs(func, _func)
+ ## posify the expression
+ num, reps = posify(num)
+ s = simplify(num).xreplace(reps).xreplace({_func: func})
+ testnum += 1
+ else:
+ break
+
+ if not s:
+ return (True, s)
+ elif s is True: # The code above never was able to change s
+ raise NotImplementedError("Unable to test if " + str(sol) +
+ " is a solution to " + str(ode) + ".")
+ else:
+ return (False, s)
+
+
+def checksysodesol(eqs, sols, func=None):
+ r"""
+ Substitutes corresponding ``sols`` for each functions into each ``eqs`` and
+ checks that the result of substitutions for each equation is ``0``. The
+ equations and solutions passed can be any iterable.
+
+ This only works when each ``sols`` have one function only, like `x(t)` or `y(t)`.
+ For each function, ``sols`` can have a single solution or a list of solutions.
+ In most cases it will not be necessary to explicitly identify the function,
+ but if the function cannot be inferred from the original equation it
+ can be supplied through the ``func`` argument.
+
+ When a sequence of equations is passed, the same sequence is used to return
+ the result for each equation with each function substituted with corresponding
+ solutions.
+
+ It tries the following method to find zero equivalence for each equation:
+
+ Substitute the solutions for functions, like `x(t)` and `y(t)` into the
+ original equations containing those functions.
+ This function returns a tuple. The first item in the tuple is ``True`` if
+ the substitution results for each equation is ``0``, and ``False`` otherwise.
+ The second item in the tuple is what the substitution results in. Each element
+ of the ``list`` should always be ``0`` corresponding to each equation if the
+ first item is ``True``. Note that sometimes this function may return ``False``,
+ but with an expression that is identically equal to ``0``, instead of returning
+ ``True``. This is because :py:meth:`~sympy.simplify.simplify.simplify` cannot
+ reduce the expression to ``0``. If an expression returned by each function
+ vanishes identically, then ``sols`` really is a solution to ``eqs``.
+
+ If this function seems to hang, it is probably because of a difficult simplification.
+
+ Examples
+ ========
+
+ >>> from sympy import Eq, diff, symbols, sin, cos, exp, sqrt, S, Function
+ >>> from sympy.solvers.ode.subscheck import checksysodesol
+ >>> C1, C2 = symbols('C1:3')
+ >>> t = symbols('t')
+ >>> x, y = symbols('x, y', cls=Function)
+ >>> eq = (Eq(diff(x(t),t), x(t) + y(t) + 17), Eq(diff(y(t),t), -2*x(t) + y(t) + 12))
+ >>> sol = [Eq(x(t), (C1*sin(sqrt(2)*t) + C2*cos(sqrt(2)*t))*exp(t) - S(5)/3),
+ ... Eq(y(t), (sqrt(2)*C1*cos(sqrt(2)*t) - sqrt(2)*C2*sin(sqrt(2)*t))*exp(t) - S(46)/3)]
+ >>> checksysodesol(eq, sol)
+ (True, [0, 0])
+ >>> eq = (Eq(diff(x(t),t),x(t)*y(t)**4), Eq(diff(y(t),t),y(t)**3))
+ >>> sol = [Eq(x(t), C1*exp(-1/(4*(C2 + t)))), Eq(y(t), -sqrt(2)*sqrt(-1/(C2 + t))/2),
+ ... Eq(x(t), C1*exp(-1/(4*(C2 + t)))), Eq(y(t), sqrt(2)*sqrt(-1/(C2 + t))/2)]
+ >>> checksysodesol(eq, sol)
+ (True, [0, 0])
+
+ """
+ def _sympify(eq):
+ return list(map(sympify, eq if iterable(eq) else [eq]))
+ eqs = _sympify(eqs)
+ for i in range(len(eqs)):
+ if isinstance(eqs[i], Equality):
+ eqs[i] = eqs[i].lhs - eqs[i].rhs
+ if func is None:
+ funcs = []
+ for eq in eqs:
+ derivs = eq.atoms(Derivative)
+ func = set().union(*[d.atoms(AppliedUndef) for d in derivs])
+ funcs.extend(func)
+ funcs = list(set(funcs))
+ if not all(isinstance(func, AppliedUndef) and len(func.args) == 1 for func in funcs)\
+ and len({func.args for func in funcs})!=1:
+ raise ValueError("func must be a function of one variable, not %s" % func)
+ for sol in sols:
+ if len(sol.atoms(AppliedUndef)) != 1:
+ raise ValueError("solutions should have one function only")
+ if len(funcs) != len({sol.lhs for sol in sols}):
+ raise ValueError("number of solutions provided does not match the number of equations")
+ dictsol = {}
+ for sol in sols:
+ func = list(sol.atoms(AppliedUndef))[0]
+ if sol.rhs == func:
+ sol = sol.reversed
+ solved = sol.lhs == func and not sol.rhs.has(func)
+ if not solved:
+ rhs = solve(sol, func)
+ if not rhs:
+ raise NotImplementedError
+ else:
+ rhs = sol.rhs
+ dictsol[func] = rhs
+ checkeq = []
+ for eq in eqs:
+ for func in funcs:
+ eq = sub_func_doit(eq, func, dictsol[func])
+ ss = simplify(eq)
+ if ss != 0:
+ eq = ss.expand(force=True)
+ if eq != 0:
+ eq = sqrtdenest(eq).simplify()
+ else:
+ eq = 0
+ checkeq.append(eq)
+ if len(set(checkeq)) == 1 and list(set(checkeq))[0] == 0:
+ return (True, checkeq)
+ else:
+ return (False, checkeq)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/systems.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/systems.py
new file mode 100644
index 0000000000000000000000000000000000000000..c0cbd51156d4d8c088e887ff078b3e14621db435
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/systems.py
@@ -0,0 +1,2135 @@
+from sympy.core import Add, Mul, S
+from sympy.core.containers import Tuple
+from sympy.core.exprtools import factor_terms
+from sympy.core.numbers import I
+from sympy.core.relational import Eq, Equality
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.core.symbol import Dummy, Symbol
+from sympy.core.function import (expand_mul, expand, Derivative,
+ AppliedUndef, Function, Subs)
+from sympy.functions import (exp, im, cos, sin, re, Piecewise,
+ piecewise_fold, sqrt, log)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.matrices import zeros, Matrix, NonSquareMatrixError, MatrixBase, eye
+from sympy.polys import Poly, together
+from sympy.simplify import collect, radsimp, signsimp # type: ignore
+from sympy.simplify.powsimp import powdenest, powsimp
+from sympy.simplify.ratsimp import ratsimp
+from sympy.simplify.simplify import simplify
+from sympy.sets.sets import FiniteSet
+from sympy.solvers.deutils import ode_order
+from sympy.solvers.solveset import NonlinearError, solveset
+from sympy.utilities.iterables import (connected_components, iterable,
+ strongly_connected_components)
+from sympy.utilities.misc import filldedent
+from sympy.integrals.integrals import Integral, integrate
+
+
+def _get_func_order(eqs, funcs):
+ return {func: max(ode_order(eq, func) for eq in eqs) for func in funcs}
+
+
+class ODEOrderError(ValueError):
+ """Raised by linear_ode_to_matrix if the system has the wrong order"""
+ pass
+
+
+class ODENonlinearError(NonlinearError):
+ """Raised by linear_ode_to_matrix if the system is nonlinear"""
+ pass
+
+
+def _simpsol(soleq):
+ lhs = soleq.lhs
+ sol = soleq.rhs
+ sol = powsimp(sol)
+ gens = list(sol.atoms(exp))
+ p = Poly(sol, *gens, expand=False)
+ gens = [factor_terms(g) for g in gens]
+ if not gens:
+ gens = p.gens
+ syms = [Symbol('C1'), Symbol('C2')]
+ terms = []
+ for coeff, monom in zip(p.coeffs(), p.monoms()):
+ coeff = piecewise_fold(coeff)
+ if isinstance(coeff, Piecewise):
+ coeff = Piecewise(*((ratsimp(coef).collect(syms), cond) for coef, cond in coeff.args))
+ else:
+ coeff = ratsimp(coeff).collect(syms)
+ monom = Mul(*(g ** i for g, i in zip(gens, monom)))
+ terms.append(coeff * monom)
+ return Eq(lhs, Add(*terms))
+
+
+def _solsimp(e, t):
+ no_t, has_t = powsimp(expand_mul(e)).as_independent(t)
+
+ no_t = ratsimp(no_t)
+ has_t = has_t.replace(exp, lambda a: exp(factor_terms(a)))
+
+ return no_t + has_t
+
+
+def simpsol(sol, wrt1, wrt2, doit=True):
+ """Simplify solutions from dsolve_system."""
+
+ # The parameter sol is the solution as returned by dsolve (list of Eq).
+ #
+ # The parameters wrt1 and wrt2 are lists of symbols to be collected for
+ # with those in wrt1 being collected for first. This allows for collecting
+ # on any factors involving the independent variable before collecting on
+ # the integration constants or vice versa using e.g.:
+ #
+ # sol = simpsol(sol, [t], [C1, C2]) # t first, constants after
+ # sol = simpsol(sol, [C1, C2], [t]) # constants first, t after
+ #
+ # If doit=True (default) then simpsol will begin by evaluating any
+ # unevaluated integrals. Since many integrals will appear multiple times
+ # in the solutions this is done intelligently by computing each integral
+ # only once.
+ #
+ # The strategy is to first perform simple cancellation with factor_terms
+ # and then multiply out all brackets with expand_mul. This gives an Add
+ # with many terms.
+ #
+ # We split each term into two multiplicative factors dep and coeff where
+ # all factors that involve wrt1 are in dep and any constant factors are in
+ # coeff e.g.
+ # sqrt(2)*C1*exp(t) -> ( exp(t), sqrt(2)*C1 )
+ #
+ # The dep factors are simplified using powsimp to combine expanded
+ # exponential factors e.g.
+ # exp(a*t)*exp(b*t) -> exp(t*(a+b))
+ #
+ # We then collect coefficients for all terms having the same (simplified)
+ # dep. The coefficients are then simplified using together and ratsimp and
+ # lastly by recursively applying the same transformation to the
+ # coefficients to collect on wrt2.
+ #
+ # Finally the result is recombined into an Add and signsimp is used to
+ # normalise any minus signs.
+
+ def simprhs(rhs, rep, wrt1, wrt2):
+ """Simplify the rhs of an ODE solution"""
+ if rep:
+ rhs = rhs.subs(rep)
+ rhs = factor_terms(rhs)
+ rhs = simp_coeff_dep(rhs, wrt1, wrt2)
+ rhs = signsimp(rhs)
+ return rhs
+
+ def simp_coeff_dep(expr, wrt1, wrt2=None):
+ """Split rhs into terms, split terms into dep and coeff and collect on dep"""
+ add_dep_terms = lambda e: e.is_Add and e.has(*wrt1)
+ expandable = lambda e: e.is_Mul and any(map(add_dep_terms, e.args))
+ expand_func = lambda e: expand_mul(e, deep=False)
+ expand_mul_mod = lambda e: e.replace(expandable, expand_func)
+ terms = Add.make_args(expand_mul_mod(expr))
+ dc = {}
+ for term in terms:
+ coeff, dep = term.as_independent(*wrt1, as_Add=False)
+ # Collect together the coefficients for terms that have the same
+ # dependence on wrt1 (after dep is normalised using simpdep).
+ dep = simpdep(dep, wrt1)
+
+ # See if the dependence on t cancels out...
+ if dep is not S.One:
+ dep2 = factor_terms(dep)
+ if not dep2.has(*wrt1):
+ coeff *= dep2
+ dep = S.One
+
+ if dep not in dc:
+ dc[dep] = coeff
+ else:
+ dc[dep] += coeff
+ # Apply the method recursively to the coefficients but this time
+ # collecting on wrt2 rather than wrt2.
+ termpairs = ((simpcoeff(c, wrt2), d) for d, c in dc.items())
+ if wrt2 is not None:
+ termpairs = ((simp_coeff_dep(c, wrt2), d) for c, d in termpairs)
+ return Add(*(c * d for c, d in termpairs))
+
+ def simpdep(term, wrt1):
+ """Normalise factors involving t with powsimp and recombine exp"""
+ def canonicalise(a):
+ # Using factor_terms here isn't quite right because it leads to things
+ # like exp(t*(1+t)) that we don't want. We do want to cancel factors
+ # and pull out a common denominator but ideally the numerator would be
+ # expressed as a standard form polynomial in t so we expand_mul
+ # and collect afterwards.
+ a = factor_terms(a)
+ num, den = a.as_numer_denom()
+ num = expand_mul(num)
+ num = collect(num, wrt1)
+ return num / den
+
+ term = powsimp(term)
+ rep = {e: exp(canonicalise(e.args[0])) for e in term.atoms(exp)}
+ term = term.subs(rep)
+ return term
+
+ def simpcoeff(coeff, wrt2):
+ """Bring to a common fraction and cancel with ratsimp"""
+ coeff = together(coeff)
+ if coeff.is_polynomial():
+ # Calling ratsimp can be expensive. The main reason is to simplify
+ # sums of terms with irrational denominators so we limit ourselves
+ # to the case where the expression is polynomial in any symbols.
+ # Maybe there's a better approach...
+ coeff = ratsimp(radsimp(coeff))
+ # collect on secondary variables first and any remaining symbols after
+ if wrt2 is not None:
+ syms = list(wrt2) + list(ordered(coeff.free_symbols - set(wrt2)))
+ else:
+ syms = list(ordered(coeff.free_symbols))
+ coeff = collect(coeff, syms)
+ coeff = together(coeff)
+ return coeff
+
+ # There are often repeated integrals. Collect unique integrals and
+ # evaluate each once and then substitute into the final result to replace
+ # all occurrences in each of the solution equations.
+ if doit:
+ integrals = set().union(*(s.atoms(Integral) for s in sol))
+ rep = {i: factor_terms(i).doit() for i in integrals}
+ else:
+ rep = {}
+
+ sol = [Eq(s.lhs, simprhs(s.rhs, rep, wrt1, wrt2)) for s in sol]
+ return sol
+
+
+def linodesolve_type(A, t, b=None):
+ r"""
+ Helper function that determines the type of the system of ODEs for solving with :obj:`sympy.solvers.ode.systems.linodesolve()`
+
+ Explanation
+ ===========
+
+ This function takes in the coefficient matrix and/or the non-homogeneous term
+ and returns the type of the equation that can be solved by :obj:`sympy.solvers.ode.systems.linodesolve()`.
+
+ If the system is constant coefficient homogeneous, then "type1" is returned
+
+ If the system is constant coefficient non-homogeneous, then "type2" is returned
+
+ If the system is non-constant coefficient homogeneous, then "type3" is returned
+
+ If the system is non-constant coefficient non-homogeneous, then "type4" is returned
+
+ If the system has a non-constant coefficient matrix which can be factorized into constant
+ coefficient matrix, then "type5" or "type6" is returned for when the system is homogeneous or
+ non-homogeneous respectively.
+
+ Note that, if the system of ODEs is of "type3" or "type4", then along with the type,
+ the commutative antiderivative of the coefficient matrix is also returned.
+
+ If the system cannot be solved by :obj:`sympy.solvers.ode.systems.linodesolve()`, then
+ NotImplementedError is raised.
+
+ Parameters
+ ==========
+
+ A : Matrix
+ Coefficient matrix of the system of ODEs
+ b : Matrix or None
+ Non-homogeneous term of the system. The default value is None.
+ If this argument is None, then the system is assumed to be homogeneous.
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, Matrix
+ >>> from sympy.solvers.ode.systems import linodesolve_type
+ >>> t = symbols("t")
+ >>> A = Matrix([[1, 1], [2, 3]])
+ >>> b = Matrix([t, 1])
+
+ >>> linodesolve_type(A, t)
+ {'antiderivative': None, 'type_of_equation': 'type1'}
+
+ >>> linodesolve_type(A, t, b=b)
+ {'antiderivative': None, 'type_of_equation': 'type2'}
+
+ >>> A_t = Matrix([[1, t], [-t, 1]])
+
+ >>> linodesolve_type(A_t, t)
+ {'antiderivative': Matrix([
+ [ t, t**2/2],
+ [-t**2/2, t]]), 'type_of_equation': 'type3'}
+
+ >>> linodesolve_type(A_t, t, b=b)
+ {'antiderivative': Matrix([
+ [ t, t**2/2],
+ [-t**2/2, t]]), 'type_of_equation': 'type4'}
+
+ >>> A_non_commutative = Matrix([[1, t], [t, -1]])
+ >>> linodesolve_type(A_non_commutative, t)
+ Traceback (most recent call last):
+ ...
+ NotImplementedError:
+ The system does not have a commutative antiderivative, it cannot be
+ solved by linodesolve.
+
+ Returns
+ =======
+
+ Dict
+
+ Raises
+ ======
+
+ NotImplementedError
+ When the coefficient matrix does not have a commutative antiderivative
+
+ See Also
+ ========
+
+ linodesolve: Function for which linodesolve_type gets the information
+
+ """
+
+ match = {}
+ is_non_constant = not _matrix_is_constant(A, t)
+ is_non_homogeneous = not (b is None or b.is_zero_matrix)
+ type = "type{}".format(int("{}{}".format(int(is_non_constant), int(is_non_homogeneous)), 2) + 1)
+
+ B = None
+ match.update({"type_of_equation": type, "antiderivative": B})
+
+ if is_non_constant:
+ B, is_commuting = _is_commutative_anti_derivative(A, t)
+ if not is_commuting:
+ raise NotImplementedError(filldedent('''
+ The system does not have a commutative antiderivative, it cannot be solved
+ by linodesolve.
+ '''))
+
+ match['antiderivative'] = B
+ match.update(_first_order_type5_6_subs(A, t, b=b))
+
+ return match
+
+
+def _first_order_type5_6_subs(A, t, b=None):
+ match = {}
+
+ factor_terms = _factor_matrix(A, t)
+ is_homogeneous = b is None or b.is_zero_matrix
+
+ if factor_terms is not None:
+ t_ = Symbol("{}_".format(t))
+ F_t = integrate(factor_terms[0], t)
+ inverse = solveset(Eq(t_, F_t), t)
+
+ # Note: A simple way to check if a function is invertible
+ # or not.
+ if isinstance(inverse, FiniteSet) and not inverse.has(Piecewise)\
+ and len(inverse) == 1:
+
+ A = factor_terms[1]
+ if not is_homogeneous:
+ b = b / factor_terms[0]
+ b = b.subs(t, list(inverse)[0])
+ type = "type{}".format(5 + (not is_homogeneous))
+ match.update({'func_coeff': A, 'tau': F_t,
+ 't_': t_, 'type_of_equation': type, 'rhs': b})
+
+ return match
+
+
+def linear_ode_to_matrix(eqs, funcs, t, order):
+ r"""
+ Convert a linear system of ODEs to matrix form
+
+ Explanation
+ ===========
+
+ Express a system of linear ordinary differential equations as a single
+ matrix differential equation [1]. For example the system $x' = x + y + 1$
+ and $y' = x - y$ can be represented as
+
+ .. math:: A_1 X' = A_0 X + b
+
+ where $A_1$ and $A_0$ are $2 \times 2$ matrices and $b$, $X$ and $X'$ are
+ $2 \times 1$ matrices with $X = [x, y]^T$.
+
+ Higher-order systems are represented with additional matrices e.g. a
+ second-order system would look like
+
+ .. math:: A_2 X'' = A_1 X' + A_0 X + b
+
+ Examples
+ ========
+
+ >>> from sympy import Function, Symbol, Matrix, Eq
+ >>> from sympy.solvers.ode.systems import linear_ode_to_matrix
+ >>> t = Symbol('t')
+ >>> x = Function('x')
+ >>> y = Function('y')
+
+ We can create a system of linear ODEs like
+
+ >>> eqs = [
+ ... Eq(x(t).diff(t), x(t) + y(t) + 1),
+ ... Eq(y(t).diff(t), x(t) - y(t)),
+ ... ]
+ >>> funcs = [x(t), y(t)]
+ >>> order = 1 # 1st order system
+
+ Now ``linear_ode_to_matrix`` can represent this as a matrix
+ differential equation.
+
+ >>> (A1, A0), b = linear_ode_to_matrix(eqs, funcs, t, order)
+ >>> A1
+ Matrix([
+ [1, 0],
+ [0, 1]])
+ >>> A0
+ Matrix([
+ [1, 1],
+ [1, -1]])
+ >>> b
+ Matrix([
+ [1],
+ [0]])
+
+ The original equations can be recovered from these matrices:
+
+ >>> eqs_mat = Matrix([eq.lhs - eq.rhs for eq in eqs])
+ >>> X = Matrix(funcs)
+ >>> A1 * X.diff(t) - A0 * X - b == eqs_mat
+ True
+
+ If the system of equations has a maximum order greater than the
+ order of the system specified, a ODEOrderError exception is raised.
+
+ >>> eqs = [Eq(x(t).diff(t, 2), x(t).diff(t) + x(t)), Eq(y(t).diff(t), y(t) + x(t))]
+ >>> linear_ode_to_matrix(eqs, funcs, t, 1)
+ Traceback (most recent call last):
+ ...
+ ODEOrderError: Cannot represent system in 1-order form
+
+ If the system of equations is nonlinear, then ODENonlinearError is
+ raised.
+
+ >>> eqs = [Eq(x(t).diff(t), x(t) + y(t)), Eq(y(t).diff(t), y(t)**2 + x(t))]
+ >>> linear_ode_to_matrix(eqs, funcs, t, 1)
+ Traceback (most recent call last):
+ ...
+ ODENonlinearError: The system of ODEs is nonlinear.
+
+ Parameters
+ ==========
+
+ eqs : list of SymPy expressions or equalities
+ The equations as expressions (assumed equal to zero).
+ funcs : list of applied functions
+ The dependent variables of the system of ODEs.
+ t : symbol
+ The independent variable.
+ order : int
+ The order of the system of ODEs.
+
+ Returns
+ =======
+
+ The tuple ``(As, b)`` where ``As`` is a tuple of matrices and ``b`` is the
+ the matrix representing the rhs of the matrix equation.
+
+ Raises
+ ======
+
+ ODEOrderError
+ When the system of ODEs have an order greater than what was specified
+ ODENonlinearError
+ When the system of ODEs is nonlinear
+
+ See Also
+ ========
+
+ linear_eq_to_matrix: for systems of linear algebraic equations.
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Matrix_differential_equation
+
+ """
+ from sympy.solvers.solveset import linear_eq_to_matrix
+
+ if any(ode_order(eq, func) > order for eq in eqs for func in funcs):
+ msg = "Cannot represent system in {}-order form"
+ raise ODEOrderError(msg.format(order))
+
+ As = []
+
+ for o in range(order, -1, -1):
+ # Work from the highest derivative down
+ syms = [func.diff(t, o) for func in funcs]
+
+ # Ai is the matrix for X(t).diff(t, o)
+ # eqs is minus the remainder of the equations.
+ try:
+ Ai, b = linear_eq_to_matrix(eqs, syms)
+ except NonlinearError:
+ raise ODENonlinearError("The system of ODEs is nonlinear.")
+
+ Ai = Ai.applyfunc(expand_mul)
+
+ As.append(Ai if o == order else -Ai)
+
+ if o:
+ eqs = [-eq for eq in b]
+ else:
+ rhs = b
+
+ return As, rhs
+
+
+def matrix_exp(A, t):
+ r"""
+ Matrix exponential $\exp(A*t)$ for the matrix ``A`` and scalar ``t``.
+
+ Explanation
+ ===========
+
+ This functions returns the $\exp(A*t)$ by doing a simple
+ matrix multiplication:
+
+ .. math:: \exp(A*t) = P * expJ * P^{-1}
+
+ where $expJ$ is $\exp(J*t)$. $J$ is the Jordan normal
+ form of $A$ and $P$ is matrix such that:
+
+ .. math:: A = P * J * P^{-1}
+
+ The matrix exponential $\exp(A*t)$ appears in the solution of linear
+ differential equations. For example if $x$ is a vector and $A$ is a matrix
+ then the initial value problem
+
+ .. math:: \frac{dx(t)}{dt} = A \times x(t), x(0) = x0
+
+ has the unique solution
+
+ .. math:: x(t) = \exp(A t) x0
+
+ Examples
+ ========
+
+ >>> from sympy import Symbol, Matrix, pprint
+ >>> from sympy.solvers.ode.systems import matrix_exp
+ >>> t = Symbol('t')
+
+ We will consider a 2x2 matrix for comupting the exponential
+
+ >>> A = Matrix([[2, -5], [2, -4]])
+ >>> pprint(A)
+ [2 -5]
+ [ ]
+ [2 -4]
+
+ Now, exp(A*t) is given as follows:
+
+ >>> pprint(matrix_exp(A, t))
+ [ -t -t -t ]
+ [3*e *sin(t) + e *cos(t) -5*e *sin(t) ]
+ [ ]
+ [ -t -t -t ]
+ [ 2*e *sin(t) - 3*e *sin(t) + e *cos(t)]
+
+ Parameters
+ ==========
+
+ A : Matrix
+ The matrix $A$ in the expression $\exp(A*t)$
+ t : Symbol
+ The independent variable
+
+ See Also
+ ========
+
+ matrix_exp_jordan_form: For exponential of Jordan normal form
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Jordan_normal_form
+ .. [2] https://en.wikipedia.org/wiki/Matrix_exponential
+
+ """
+ P, expJ = matrix_exp_jordan_form(A, t)
+ return P * expJ * P.inv()
+
+
+def matrix_exp_jordan_form(A, t):
+ r"""
+ Matrix exponential $\exp(A*t)$ for the matrix *A* and scalar *t*.
+
+ Explanation
+ ===========
+
+ Returns the Jordan form of the $\exp(A*t)$ along with the matrix $P$ such that:
+
+ .. math::
+ \exp(A*t) = P * expJ * P^{-1}
+
+ Examples
+ ========
+
+ >>> from sympy import Matrix, Symbol
+ >>> from sympy.solvers.ode.systems import matrix_exp, matrix_exp_jordan_form
+ >>> t = Symbol('t')
+
+ We will consider a 2x2 defective matrix. This shows that our method
+ works even for defective matrices.
+
+ >>> A = Matrix([[1, 1], [0, 1]])
+
+ It can be observed that this function gives us the Jordan normal form
+ and the required invertible matrix P.
+
+ >>> P, expJ = matrix_exp_jordan_form(A, t)
+
+ Here, it is shown that P and expJ returned by this function is correct
+ as they satisfy the formula: P * expJ * P_inverse = exp(A*t).
+
+ >>> P * expJ * P.inv() == matrix_exp(A, t)
+ True
+
+ Parameters
+ ==========
+
+ A : Matrix
+ The matrix $A$ in the expression $\exp(A*t)$
+ t : Symbol
+ The independent variable
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Defective_matrix
+ .. [2] https://en.wikipedia.org/wiki/Jordan_matrix
+ .. [3] https://en.wikipedia.org/wiki/Jordan_normal_form
+
+ """
+
+ N, M = A.shape
+ if N != M:
+ raise ValueError('Needed square matrix but got shape (%s, %s)' % (N, M))
+ elif A.has(t):
+ raise ValueError('Matrix A should not depend on t')
+
+ def jordan_chains(A):
+ '''Chains from Jordan normal form analogous to M.eigenvects().
+ Returns a dict with eignevalues as keys like:
+ {e1: [[v111,v112,...], [v121, v122,...]], e2:...}
+ where vijk is the kth vector in the jth chain for eigenvalue i.
+ '''
+ P, blocks = A.jordan_cells()
+ basis = [P[:,i] for i in range(P.shape[1])]
+ n = 0
+ chains = {}
+ for b in blocks:
+ eigval = b[0, 0]
+ size = b.shape[0]
+ if eigval not in chains:
+ chains[eigval] = []
+ chains[eigval].append(basis[n:n+size])
+ n += size
+ return chains
+
+ eigenchains = jordan_chains(A)
+
+ # Needed for consistency across Python versions
+ eigenchains_iter = sorted(eigenchains.items(), key=default_sort_key)
+ isreal = not A.has(I)
+
+ blocks = []
+ vectors = []
+ seen_conjugate = set()
+ for e, chains in eigenchains_iter:
+ for chain in chains:
+ n = len(chain)
+ if isreal and e != e.conjugate() and e.conjugate() in eigenchains:
+ if e in seen_conjugate:
+ continue
+ seen_conjugate.add(e.conjugate())
+ exprt = exp(re(e) * t)
+ imrt = im(e) * t
+ imblock = Matrix([[cos(imrt), sin(imrt)],
+ [-sin(imrt), cos(imrt)]])
+ expJblock2 = Matrix(n, n, lambda i,j:
+ imblock * t**(j-i) / factorial(j-i) if j >= i
+ else zeros(2, 2))
+ expJblock = Matrix(2*n, 2*n, lambda i,j: expJblock2[i//2,j//2][i%2,j%2])
+
+ blocks.append(exprt * expJblock)
+ for i in range(n):
+ vectors.append(re(chain[i]))
+ vectors.append(im(chain[i]))
+ else:
+ vectors.extend(chain)
+ fun = lambda i,j: t**(j-i)/factorial(j-i) if j >= i else 0
+ expJblock = Matrix(n, n, fun)
+ blocks.append(exp(e * t) * expJblock)
+
+ expJ = Matrix.diag(*blocks)
+ P = Matrix(N, N, lambda i,j: vectors[j][i])
+
+ return P, expJ
+
+
+# Note: To add a docstring example with tau
+def linodesolve(A, t, b=None, B=None, type="auto", doit=False,
+ tau=None):
+ r"""
+ System of n equations linear first-order differential equations
+
+ Explanation
+ ===========
+
+ This solver solves the system of ODEs of the following form:
+
+ .. math::
+ X'(t) = A(t) X(t) + b(t)
+
+ Here, $A(t)$ is the coefficient matrix, $X(t)$ is the vector of n independent variables,
+ $b(t)$ is the non-homogeneous term and $X'(t)$ is the derivative of $X(t)$
+
+ Depending on the properties of $A(t)$ and $b(t)$, this solver evaluates the solution
+ differently.
+
+ When $A(t)$ is constant coefficient matrix and $b(t)$ is zero vector i.e. system is homogeneous,
+ the system is "type1". The solution is:
+
+ .. math::
+ X(t) = \exp(A t) C
+
+ Here, $C$ is a vector of constants and $A$ is the constant coefficient matrix.
+
+ When $A(t)$ is constant coefficient matrix and $b(t)$ is non-zero i.e. system is non-homogeneous,
+ the system is "type2". The solution is:
+
+ .. math::
+ X(t) = e^{A t} ( \int e^{- A t} b \,dt + C)
+
+ When $A(t)$ is coefficient matrix such that its commutative with its antiderivative $B(t)$ and
+ $b(t)$ is a zero vector i.e. system is homogeneous, the system is "type3". The solution is:
+
+ .. math::
+ X(t) = \exp(B(t)) C
+
+ When $A(t)$ is commutative with its antiderivative $B(t)$ and $b(t)$ is non-zero i.e. system is
+ non-homogeneous, the system is "type4". The solution is:
+
+ .. math::
+ X(t) = e^{B(t)} ( \int e^{-B(t)} b(t) \,dt + C)
+
+ When $A(t)$ is a coefficient matrix such that it can be factorized into a scalar and a constant
+ coefficient matrix:
+
+ .. math::
+ A(t) = f(t) * A
+
+ Where $f(t)$ is a scalar expression in the independent variable $t$ and $A$ is a constant matrix,
+ then we can do the following substitutions:
+
+ .. math::
+ tau = \int f(t) dt, X(t) = Y(tau), b(t) = b(f^{-1}(tau))
+
+ Here, the substitution for the non-homogeneous term is done only when its non-zero.
+ Using these substitutions, our original system becomes:
+
+ .. math::
+ Y'(tau) = A * Y(tau) + b(tau)/f(tau)
+
+ The above system can be easily solved using the solution for "type1" or "type2" depending
+ on the homogeneity of the system. After we get the solution for $Y(tau)$, we substitute the
+ solution for $tau$ as $t$ to get back $X(t)$
+
+ .. math::
+ X(t) = Y(tau)
+
+ Systems of "type5" and "type6" have a commutative antiderivative but we use this solution
+ because its faster to compute.
+
+ The final solution is the general solution for all the four equations since a constant coefficient
+ matrix is always commutative with its antidervative.
+
+ An additional feature of this function is, if someone wants to substitute for value of the independent
+ variable, they can pass the substitution `tau` and the solution will have the independent variable
+ substituted with the passed expression(`tau`).
+
+ Parameters
+ ==========
+
+ A : Matrix
+ Coefficient matrix of the system of linear first order ODEs.
+ t : Symbol
+ Independent variable in the system of ODEs.
+ b : Matrix or None
+ Non-homogeneous term in the system of ODEs. If None is passed,
+ a homogeneous system of ODEs is assumed.
+ B : Matrix or None
+ Antiderivative of the coefficient matrix. If the antiderivative
+ is not passed and the solution requires the term, then the solver
+ would compute it internally.
+ type : String
+ Type of the system of ODEs passed. Depending on the type, the
+ solution is evaluated. The type values allowed and the corresponding
+ system it solves are: "type1" for constant coefficient homogeneous
+ "type2" for constant coefficient non-homogeneous, "type3" for non-constant
+ coefficient homogeneous, "type4" for non-constant coefficient non-homogeneous,
+ "type5" and "type6" for non-constant coefficient homogeneous and non-homogeneous
+ systems respectively where the coefficient matrix can be factorized to a constant
+ coefficient matrix.
+ The default value is "auto" which will let the solver decide the correct type of
+ the system passed.
+ doit : Boolean
+ Evaluate the solution if True, default value is False
+ tau: Expression
+ Used to substitute for the value of `t` after we get the solution of the system.
+
+ Examples
+ ========
+
+ To solve the system of ODEs using this function directly, several things must be
+ done in the right order. Wrong inputs to the function will lead to incorrect results.
+
+ >>> from sympy import symbols, Function, Eq
+ >>> from sympy.solvers.ode.systems import canonical_odes, linear_ode_to_matrix, linodesolve, linodesolve_type
+ >>> from sympy.solvers.ode.subscheck import checkodesol
+ >>> f, g = symbols("f, g", cls=Function)
+ >>> x, a = symbols("x, a")
+ >>> funcs = [f(x), g(x)]
+ >>> eqs = [Eq(f(x).diff(x) - f(x), a*g(x) + 1), Eq(g(x).diff(x) + g(x), a*f(x))]
+
+ Here, it is important to note that before we derive the coefficient matrix, it is
+ important to get the system of ODEs into the desired form. For that we will use
+ :obj:`sympy.solvers.ode.systems.canonical_odes()`.
+
+ >>> eqs = canonical_odes(eqs, funcs, x)
+ >>> eqs
+ [[Eq(Derivative(f(x), x), a*g(x) + f(x) + 1), Eq(Derivative(g(x), x), a*f(x) - g(x))]]
+
+ Now, we will use :obj:`sympy.solvers.ode.systems.linear_ode_to_matrix()` to get the coefficient matrix and the
+ non-homogeneous term if it is there.
+
+ >>> eqs = eqs[0]
+ >>> (A1, A0), b = linear_ode_to_matrix(eqs, funcs, x, 1)
+ >>> A = A0
+
+ We have the coefficient matrices and the non-homogeneous term ready. Now, we can use
+ :obj:`sympy.solvers.ode.systems.linodesolve_type()` to get the information for the system of ODEs
+ to finally pass it to the solver.
+
+ >>> system_info = linodesolve_type(A, x, b=b)
+ >>> sol_vector = linodesolve(A, x, b=b, B=system_info['antiderivative'], type=system_info['type_of_equation'])
+
+ Now, we can prove if the solution is correct or not by using :obj:`sympy.solvers.ode.checkodesol()`
+
+ >>> sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)]
+ >>> checkodesol(eqs, sol)
+ (True, [0, 0])
+
+ We can also use the doit method to evaluate the solutions passed by the function.
+
+ >>> sol_vector_evaluated = linodesolve(A, x, b=b, type="type2", doit=True)
+
+ Now, we will look at a system of ODEs which is non-constant.
+
+ >>> eqs = [Eq(f(x).diff(x), f(x) + x*g(x)), Eq(g(x).diff(x), -x*f(x) + g(x))]
+
+ The system defined above is already in the desired form, so we do not have to convert it.
+
+ >>> (A1, A0), b = linear_ode_to_matrix(eqs, funcs, x, 1)
+ >>> A = A0
+
+ A user can also pass the commutative antiderivative required for type3 and type4 system of ODEs.
+ Passing an incorrect one will lead to incorrect results. If the coefficient matrix is not commutative
+ with its antiderivative, then :obj:`sympy.solvers.ode.systems.linodesolve_type()` raises a NotImplementedError.
+ If it does have a commutative antiderivative, then the function just returns the information about the system.
+
+ >>> system_info = linodesolve_type(A, x, b=b)
+
+ Now, we can pass the antiderivative as an argument to get the solution. If the system information is not
+ passed, then the solver will compute the required arguments internally.
+
+ >>> sol_vector = linodesolve(A, x, b=b)
+
+ Once again, we can verify the solution obtained.
+
+ >>> sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)]
+ >>> checkodesol(eqs, sol)
+ (True, [0, 0])
+
+ Returns
+ =======
+
+ List
+
+ Raises
+ ======
+
+ ValueError
+ This error is raised when the coefficient matrix, non-homogeneous term
+ or the antiderivative, if passed, are not a matrix or
+ do not have correct dimensions
+ NonSquareMatrixError
+ When the coefficient matrix or its antiderivative, if passed is not a
+ square matrix
+ NotImplementedError
+ If the coefficient matrix does not have a commutative antiderivative
+
+ See Also
+ ========
+
+ linear_ode_to_matrix: Coefficient matrix computation function
+ canonical_odes: System of ODEs representation change
+ linodesolve_type: Getting information about systems of ODEs to pass in this solver
+
+ """
+
+ if not isinstance(A, MatrixBase):
+ raise ValueError(filldedent('''\
+ The coefficients of the system of ODEs should be of type Matrix
+ '''))
+
+ if not A.is_square:
+ raise NonSquareMatrixError(filldedent('''\
+ The coefficient matrix must be a square
+ '''))
+
+ if b is not None:
+ if not isinstance(b, MatrixBase):
+ raise ValueError(filldedent('''\
+ The non-homogeneous terms of the system of ODEs should be of type Matrix
+ '''))
+
+ if A.rows != b.rows:
+ raise ValueError(filldedent('''\
+ The system of ODEs should have the same number of non-homogeneous terms and the number of
+ equations
+ '''))
+
+ if B is not None:
+ if not isinstance(B, MatrixBase):
+ raise ValueError(filldedent('''\
+ The antiderivative of coefficients of the system of ODEs should be of type Matrix
+ '''))
+
+ if not B.is_square:
+ raise NonSquareMatrixError(filldedent('''\
+ The antiderivative of the coefficient matrix must be a square
+ '''))
+
+ if A.rows != B.rows:
+ raise ValueError(filldedent('''\
+ The coefficient matrix and its antiderivative should have same dimensions
+ '''))
+
+ if not any(type == "type{}".format(i) for i in range(1, 7)) and not type == "auto":
+ raise ValueError(filldedent('''\
+ The input type should be a valid one
+ '''))
+
+ n = A.rows
+
+ # constants = numbered_symbols(prefix='C', cls=Dummy, start=const_idx+1)
+ Cvect = Matrix([Dummy() for _ in range(n)])
+
+ if b is None and any(type == typ for typ in ["type2", "type4", "type6"]):
+ b = zeros(n, 1)
+
+ is_transformed = tau is not None
+ passed_type = type
+
+ if type == "auto":
+ system_info = linodesolve_type(A, t, b=b)
+ type = system_info["type_of_equation"]
+ B = system_info["antiderivative"]
+
+ if type in ("type5", "type6"):
+ is_transformed = True
+ if passed_type != "auto":
+ if tau is None:
+ system_info = _first_order_type5_6_subs(A, t, b=b)
+ if not system_info:
+ raise ValueError(filldedent('''
+ The system passed isn't {}.
+ '''.format(type)))
+
+ tau = system_info['tau']
+ t = system_info['t_']
+ A = system_info['A']
+ b = system_info['b']
+
+ intx_wrtt = lambda x: Integral(x, t) if x else 0
+ if type in ("type1", "type2", "type5", "type6"):
+ P, J = matrix_exp_jordan_form(A, t)
+ P = simplify(P)
+
+ if type in ("type1", "type5"):
+ sol_vector = P * (J * Cvect)
+ else:
+ Jinv = J.subs(t, -t)
+ sol_vector = P * J * ((Jinv * P.inv() * b).applyfunc(intx_wrtt) + Cvect)
+ else:
+ if B is None:
+ B, _ = _is_commutative_anti_derivative(A, t)
+
+ if type == "type3":
+ sol_vector = B.exp() * Cvect
+ else:
+ sol_vector = B.exp() * (((-B).exp() * b).applyfunc(intx_wrtt) + Cvect)
+
+ if is_transformed:
+ sol_vector = sol_vector.subs(t, tau)
+
+ gens = sol_vector.atoms(exp)
+
+ if type != "type1":
+ sol_vector = [expand_mul(s) for s in sol_vector]
+
+ sol_vector = [collect(s, ordered(gens), exact=True) for s in sol_vector]
+
+ if doit:
+ sol_vector = [s.doit() for s in sol_vector]
+
+ return sol_vector
+
+
+def _matrix_is_constant(M, t):
+ """Checks if the matrix M is independent of t or not."""
+ return all(coef.as_independent(t, as_Add=True)[1] == 0 for coef in M)
+
+
+def canonical_odes(eqs, funcs, t):
+ r"""
+ Function that solves for highest order derivatives in a system
+
+ Explanation
+ ===========
+
+ This function inputs a system of ODEs and based on the system,
+ the dependent variables and their highest order, returns the system
+ in the following form:
+
+ .. math::
+ X'(t) = A(t) X(t) + b(t)
+
+ Here, $X(t)$ is the vector of dependent variables of lower order, $A(t)$ is
+ the coefficient matrix, $b(t)$ is the non-homogeneous term and $X'(t)$ is the
+ vector of dependent variables in their respective highest order. We use the term
+ canonical form to imply the system of ODEs which is of the above form.
+
+ If the system passed has a non-linear term with multiple solutions, then a list of
+ systems is returned in its canonical form.
+
+ Parameters
+ ==========
+
+ eqs : List
+ List of the ODEs
+ funcs : List
+ List of dependent variables
+ t : Symbol
+ Independent variable
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, Function, Eq, Derivative
+ >>> from sympy.solvers.ode.systems import canonical_odes
+ >>> f, g = symbols("f g", cls=Function)
+ >>> x, y = symbols("x y")
+ >>> funcs = [f(x), g(x)]
+ >>> eqs = [Eq(f(x).diff(x) - 7*f(x), 12*g(x)), Eq(g(x).diff(x) + g(x), 20*f(x))]
+
+ >>> canonical_eqs = canonical_odes(eqs, funcs, x)
+ >>> canonical_eqs
+ [[Eq(Derivative(f(x), x), 7*f(x) + 12*g(x)), Eq(Derivative(g(x), x), 20*f(x) - g(x))]]
+
+ >>> system = [Eq(Derivative(f(x), x)**2 - 2*Derivative(f(x), x) + 1, 4), Eq(-y*f(x) + Derivative(g(x), x), 0)]
+
+ >>> canonical_system = canonical_odes(system, funcs, x)
+ >>> canonical_system
+ [[Eq(Derivative(f(x), x), -1), Eq(Derivative(g(x), x), y*f(x))], [Eq(Derivative(f(x), x), 3), Eq(Derivative(g(x), x), y*f(x))]]
+
+ Returns
+ =======
+
+ List
+
+ """
+ from sympy.solvers.solvers import solve
+
+ order = _get_func_order(eqs, funcs)
+
+ canon_eqs = solve(eqs, *[func.diff(t, order[func]) for func in funcs], dict=True)
+
+ systems = []
+ for eq in canon_eqs:
+ system = [Eq(func.diff(t, order[func]), eq[func.diff(t, order[func])]) for func in funcs]
+ systems.append(system)
+
+ return systems
+
+
+def _is_commutative_anti_derivative(A, t):
+ r"""
+ Helper function for determining if the Matrix passed is commutative with its antiderivative
+
+ Explanation
+ ===========
+
+ This function checks if the Matrix $A$ passed is commutative with its antiderivative with respect
+ to the independent variable $t$.
+
+ .. math::
+ B(t) = \int A(t) dt
+
+ The function outputs two values, first one being the antiderivative $B(t)$, second one being a
+ boolean value, if True, then the matrix $A(t)$ passed is commutative with $B(t)$, else the matrix
+ passed isn't commutative with $B(t)$.
+
+ Parameters
+ ==========
+
+ A : Matrix
+ The matrix which has to be checked
+ t : Symbol
+ Independent variable
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, Matrix
+ >>> from sympy.solvers.ode.systems import _is_commutative_anti_derivative
+ >>> t = symbols("t")
+ >>> A = Matrix([[1, t], [-t, 1]])
+
+ >>> B, is_commuting = _is_commutative_anti_derivative(A, t)
+ >>> is_commuting
+ True
+
+ Returns
+ =======
+
+ Matrix, Boolean
+
+ """
+ B = integrate(A, t)
+ is_commuting = (B*A - A*B).applyfunc(expand).applyfunc(factor_terms).is_zero_matrix
+
+ is_commuting = False if is_commuting is None else is_commuting
+
+ return B, is_commuting
+
+
+def _factor_matrix(A, t):
+ term = None
+ for element in A:
+ temp_term = element.as_independent(t)[1]
+ if temp_term.has(t):
+ term = temp_term
+ break
+
+ if term is not None:
+ A_factored = (A/term).applyfunc(ratsimp)
+ can_factor = _matrix_is_constant(A_factored, t)
+ term = (term, A_factored) if can_factor else None
+
+ return term
+
+
+def _is_second_order_type2(A, t):
+ term = _factor_matrix(A, t)
+ is_type2 = False
+
+ if term is not None:
+ term = 1/term[0]
+ is_type2 = term.is_polynomial()
+
+ if is_type2:
+ poly = Poly(term.expand(), t)
+ monoms = poly.monoms()
+
+ if monoms[0][0] in (2, 4):
+ cs = _get_poly_coeffs(poly, 4)
+ a, b, c, d, e = cs
+
+ a1 = powdenest(sqrt(a), force=True)
+ c1 = powdenest(sqrt(e), force=True)
+ b1 = powdenest(sqrt(c - 2*a1*c1), force=True)
+
+ is_type2 = (b == 2*a1*b1) and (d == 2*b1*c1)
+ term = a1*t**2 + b1*t + c1
+
+ else:
+ is_type2 = False
+
+ return is_type2, term
+
+
+def _get_poly_coeffs(poly, order):
+ cs = [0 for _ in range(order+1)]
+ for c, m in zip(poly.coeffs(), poly.monoms()):
+ cs[-1-m[0]] = c
+ return cs
+
+
+def _match_second_order_type(A1, A0, t, b=None):
+ r"""
+ Works only for second order system in its canonical form.
+
+ Type 0: Constant coefficient matrix, can be simply solved by
+ introducing dummy variables.
+ Type 1: When the substitution: $U = t*X' - X$ works for reducing
+ the second order system to first order system.
+ Type 2: When the system is of the form: $poly * X'' = A*X$ where
+ $poly$ is square of a quadratic polynomial with respect to
+ *t* and $A$ is a constant coefficient matrix.
+
+ """
+ match = {"type_of_equation": "type0"}
+ n = A1.shape[0]
+
+ if _matrix_is_constant(A1, t) and _matrix_is_constant(A0, t):
+ return match
+
+ if (A1 + A0*t).applyfunc(expand_mul).is_zero_matrix:
+ match.update({"type_of_equation": "type1", "A1": A1})
+
+ elif A1.is_zero_matrix and (b is None or b.is_zero_matrix):
+ is_type2, term = _is_second_order_type2(A0, t)
+ if is_type2:
+ a, b, c = _get_poly_coeffs(Poly(term, t), 2)
+ A = (A0*(term**2).expand()).applyfunc(ratsimp) + (b**2/4 - a*c)*eye(n, n)
+ tau = integrate(1/term, t)
+ t_ = Symbol("{}_".format(t))
+ match.update({"type_of_equation": "type2", "A0": A,
+ "g(t)": sqrt(term), "tau": tau, "is_transformed": True,
+ "t_": t_})
+
+ return match
+
+
+def _second_order_subs_type1(A, b, funcs, t):
+ r"""
+ For a linear, second order system of ODEs, a particular substitution.
+
+ A system of the below form can be reduced to a linear first order system of
+ ODEs:
+ .. math::
+ X'' = A(t) * (t*X' - X) + b(t)
+
+ By substituting:
+ .. math:: U = t*X' - X
+
+ To get the system:
+ .. math:: U' = t*(A(t)*U + b(t))
+
+ Where $U$ is the vector of dependent variables, $X$ is the vector of dependent
+ variables in `funcs` and $X'$ is the first order derivative of $X$ with respect to
+ $t$. It may or may not reduce the system into linear first order system of ODEs.
+
+ Then a check is made to determine if the system passed can be reduced or not, if
+ this substitution works, then the system is reduced and its solved for the new
+ substitution. After we get the solution for $U$:
+
+ .. math:: U = a(t)
+
+ We substitute and return the reduced system:
+
+ .. math::
+ a(t) = t*X' - X
+
+ Parameters
+ ==========
+
+ A: Matrix
+ Coefficient matrix($A(t)*t$) of the second order system of this form.
+ b: Matrix
+ Non-homogeneous term($b(t)$) of the system of ODEs.
+ funcs: List
+ List of dependent variables
+ t: Symbol
+ Independent variable of the system of ODEs.
+
+ Returns
+ =======
+
+ List
+
+ """
+
+ U = Matrix([t*func.diff(t) - func for func in funcs])
+
+ sol = linodesolve(A, t, t*b)
+ reduced_eqs = [Eq(u, s) for s, u in zip(sol, U)]
+ reduced_eqs = canonical_odes(reduced_eqs, funcs, t)[0]
+
+ return reduced_eqs
+
+
+def _second_order_subs_type2(A, funcs, t_):
+ r"""
+ Returns a second order system based on the coefficient matrix passed.
+
+ Explanation
+ ===========
+
+ This function returns a system of second order ODE of the following form:
+
+ .. math::
+ X'' = A * X
+
+ Here, $X$ is the vector of dependent variables, but a bit modified, $A$ is the
+ coefficient matrix passed.
+
+ Along with returning the second order system, this function also returns the new
+ dependent variables with the new independent variable `t_` passed.
+
+ Parameters
+ ==========
+
+ A: Matrix
+ Coefficient matrix of the system
+ funcs: List
+ List of old dependent variables
+ t_: Symbol
+ New independent variable
+
+ Returns
+ =======
+
+ List, List
+
+ """
+ func_names = [func.func.__name__ for func in funcs]
+ new_funcs = [Function(Dummy("{}_".format(name)))(t_) for name in func_names]
+ rhss = A * Matrix(new_funcs)
+ new_eqs = [Eq(func.diff(t_, 2), rhs) for func, rhs in zip(new_funcs, rhss)]
+
+ return new_eqs, new_funcs
+
+
+def _is_euler_system(As, t):
+ return all(_matrix_is_constant((A*t**i).applyfunc(ratsimp), t) for i, A in enumerate(As))
+
+
+def _classify_linear_system(eqs, funcs, t, is_canon=False):
+ r"""
+ Returns a dictionary with details of the eqs if the system passed is linear
+ and can be classified by this function else returns None
+
+ Explanation
+ ===========
+
+ This function takes the eqs, converts it into a form Ax = b where x is a vector of terms
+ containing dependent variables and their derivatives till their maximum order. If it is
+ possible to convert eqs into Ax = b, then all the equations in eqs are linear otherwise
+ they are non-linear.
+
+ To check if the equations are constant coefficient, we need to check if all the terms in
+ A obtained above are constant or not.
+
+ To check if the equations are homogeneous or not, we need to check if b is a zero matrix
+ or not.
+
+ Parameters
+ ==========
+
+ eqs: List
+ List of ODEs
+ funcs: List
+ List of dependent variables
+ t: Symbol
+ Independent variable of the equations in eqs
+ is_canon: Boolean
+ If True, then this function will not try to get the
+ system in canonical form. Default value is False
+
+ Returns
+ =======
+
+ match = {
+ 'no_of_equation': len(eqs),
+ 'eq': eqs,
+ 'func': funcs,
+ 'order': order,
+ 'is_linear': is_linear,
+ 'is_constant': is_constant,
+ 'is_homogeneous': is_homogeneous,
+ }
+
+ Dict or list of Dicts or None
+ Dict with values for keys:
+ 1. no_of_equation: Number of equations
+ 2. eq: The set of equations
+ 3. func: List of dependent variables
+ 4. order: A dictionary that gives the order of the
+ dependent variable in eqs
+ 5. is_linear: Boolean value indicating if the set of
+ equations are linear or not.
+ 6. is_constant: Boolean value indicating if the set of
+ equations have constant coefficients or not.
+ 7. is_homogeneous: Boolean value indicating if the set of
+ equations are homogeneous or not.
+ 8. commutative_antiderivative: Antiderivative of the coefficient
+ matrix if the coefficient matrix is non-constant
+ and commutative with its antiderivative. This key
+ may or may not exist.
+ 9. is_general: Boolean value indicating if the system of ODEs is
+ solvable using one of the general case solvers or not.
+ 10. rhs: rhs of the non-homogeneous system of ODEs in Matrix form. This
+ key may or may not exist.
+ 11. is_higher_order: True if the system passed has an order greater than 1.
+ This key may or may not exist.
+ 12. is_second_order: True if the system passed is a second order ODE. This
+ key may or may not exist.
+ This Dict is the answer returned if the eqs are linear and constant
+ coefficient. Otherwise, None is returned.
+
+ """
+
+ # Error for i == 0 can be added but isn't for now
+
+ # Check for len(funcs) == len(eqs)
+ if len(funcs) != len(eqs):
+ raise ValueError("Number of functions given is not equal to the number of equations %s" % funcs)
+
+ # ValueError when functions have more than one arguments
+ for func in funcs:
+ if len(func.args) != 1:
+ raise ValueError("dsolve() and classify_sysode() work with "
+ "functions of one variable only, not %s" % func)
+
+ # Getting the func_dict and order using the helper
+ # function
+ order = _get_func_order(eqs, funcs)
+ system_order = max(order[func] for func in funcs)
+ is_higher_order = system_order > 1
+ is_second_order = system_order == 2 and all(order[func] == 2 for func in funcs)
+
+ # Not adding the check if the len(func.args) for
+ # every func in funcs is 1
+
+ # Linearity check
+ try:
+
+ canon_eqs = canonical_odes(eqs, funcs, t) if not is_canon else [eqs]
+ if len(canon_eqs) == 1:
+ As, b = linear_ode_to_matrix(canon_eqs[0], funcs, t, system_order)
+ else:
+
+ match = {
+ 'is_implicit': True,
+ 'canon_eqs': canon_eqs
+ }
+
+ return match
+
+ # When the system of ODEs is non-linear, an ODENonlinearError is raised.
+ # This function catches the error and None is returned.
+ except ODENonlinearError:
+ return None
+
+ is_linear = True
+
+ # Homogeneous check
+ is_homogeneous = True if b.is_zero_matrix else False
+
+ # Is general key is used to identify if the system of ODEs can be solved by
+ # one of the general case solvers or not.
+ match = {
+ 'no_of_equation': len(eqs),
+ 'eq': eqs,
+ 'func': funcs,
+ 'order': order,
+ 'is_linear': is_linear,
+ 'is_homogeneous': is_homogeneous,
+ 'is_general': True
+ }
+
+ if not is_homogeneous:
+ match['rhs'] = b
+
+ is_constant = all(_matrix_is_constant(A_, t) for A_ in As)
+
+ # The match['is_linear'] check will be added in the future when this
+ # function becomes ready to deal with non-linear systems of ODEs
+
+ if not is_higher_order:
+ A = As[1]
+ match['func_coeff'] = A
+
+ # Constant coefficient check
+ is_constant = _matrix_is_constant(A, t)
+ match['is_constant'] = is_constant
+
+ try:
+ system_info = linodesolve_type(A, t, b=b)
+ except NotImplementedError:
+ return None
+
+ match.update(system_info)
+ antiderivative = match.pop("antiderivative")
+
+ if not is_constant:
+ match['commutative_antiderivative'] = antiderivative
+
+ return match
+ else:
+ match['type_of_equation'] = "type0"
+
+ if is_second_order:
+ A1, A0 = As[1:]
+
+ match_second_order = _match_second_order_type(A1, A0, t)
+ match.update(match_second_order)
+
+ match['is_second_order'] = True
+
+ # If system is constant, then no need to check if its in euler
+ # form or not. It will be easier and faster to directly proceed
+ # to solve it.
+ if match['type_of_equation'] == "type0" and not is_constant:
+ is_euler = _is_euler_system(As, t)
+ if is_euler:
+ t_ = Symbol('{}_'.format(t))
+ match.update({'is_transformed': True, 'type_of_equation': 'type1',
+ 't_': t_})
+ else:
+ is_jordan = lambda M: M == Matrix.jordan_block(M.shape[0], M[0, 0])
+ terms = _factor_matrix(As[-1], t)
+ if all(A.is_zero_matrix for A in As[1:-1]) and terms is not None and not is_jordan(terms[1]):
+ P, J = terms[1].jordan_form()
+ match.update({'type_of_equation': 'type2', 'J': J,
+ 'f(t)': terms[0], 'P': P, 'is_transformed': True})
+
+ if match['type_of_equation'] != 'type0' and is_second_order:
+ match.pop('is_second_order', None)
+
+ match['is_higher_order'] = is_higher_order
+
+ return match
+
+def _preprocess_eqs(eqs):
+ processed_eqs = []
+ for eq in eqs:
+ processed_eqs.append(eq if isinstance(eq, Equality) else Eq(eq, 0))
+
+ return processed_eqs
+
+
+def _eqs2dict(eqs, funcs):
+ eqsorig = {}
+ eqsmap = {}
+ funcset = set(funcs)
+ for eq in eqs:
+ f1, = eq.lhs.atoms(AppliedUndef)
+ f2s = (eq.rhs.atoms(AppliedUndef) - {f1}) & funcset
+ eqsmap[f1] = f2s
+ eqsorig[f1] = eq
+ return eqsmap, eqsorig
+
+
+def _dict2graph(d):
+ nodes = list(d)
+ edges = [(f1, f2) for f1, f2s in d.items() for f2 in f2s]
+ G = (nodes, edges)
+ return G
+
+
+def _is_type1(scc, t):
+ eqs, funcs = scc
+
+ try:
+ (A1, A0), b = linear_ode_to_matrix(eqs, funcs, t, 1)
+ except (ODENonlinearError, ODEOrderError):
+ return False
+
+ if _matrix_is_constant(A0, t) and b.is_zero_matrix:
+ return True
+
+ return False
+
+
+def _combine_type1_subsystems(subsystem, funcs, t):
+ indices = [i for i, sys in enumerate(zip(subsystem, funcs)) if _is_type1(sys, t)]
+ remove = set()
+ for ip, i in enumerate(indices):
+ for j in indices[ip+1:]:
+ if any(eq2.has(funcs[i]) for eq2 in subsystem[j]):
+ subsystem[j] = subsystem[i] + subsystem[j]
+ remove.add(i)
+ subsystem = [sys for i, sys in enumerate(subsystem) if i not in remove]
+ return subsystem
+
+
+def _component_division(eqs, funcs, t):
+
+ # Assuming that each eq in eqs is in canonical form,
+ # that is, [f(x).diff(x) = .., g(x).diff(x) = .., etc]
+ # and that the system passed is in its first order
+ eqsmap, eqsorig = _eqs2dict(eqs, funcs)
+
+ subsystems = []
+ for cc in connected_components(_dict2graph(eqsmap)):
+ eqsmap_c = {f: eqsmap[f] for f in cc}
+ sccs = strongly_connected_components(_dict2graph(eqsmap_c))
+ subsystem = [[eqsorig[f] for f in scc] for scc in sccs]
+ subsystem = _combine_type1_subsystems(subsystem, sccs, t)
+ subsystems.append(subsystem)
+
+ return subsystems
+
+
+# Returns: List of equations
+def _linear_ode_solver(match):
+ t = match['t']
+ funcs = match['func']
+
+ rhs = match.get('rhs', None)
+ tau = match.get('tau', None)
+ t = match['t_'] if 't_' in match else t
+ A = match['func_coeff']
+
+ # Note: To make B None when the matrix has constant
+ # coefficient
+ B = match.get('commutative_antiderivative', None)
+ type = match['type_of_equation']
+
+ sol_vector = linodesolve(A, t, b=rhs, B=B,
+ type=type, tau=tau)
+
+ sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)]
+
+ return sol
+
+
+def _select_equations(eqs, funcs, key=lambda x: x):
+ eq_dict = {e.lhs: e.rhs for e in eqs}
+ return [Eq(f, eq_dict[key(f)]) for f in funcs]
+
+
+def _higher_order_ode_solver(match):
+ eqs = match["eq"]
+ funcs = match["func"]
+ t = match["t"]
+ sysorder = match['order']
+ type = match.get('type_of_equation', "type0")
+
+ is_second_order = match.get('is_second_order', False)
+ is_transformed = match.get('is_transformed', False)
+ is_euler = is_transformed and type == "type1"
+ is_higher_order_type2 = is_transformed and type == "type2" and 'P' in match
+
+ if is_second_order:
+ new_eqs, new_funcs = _second_order_to_first_order(eqs, funcs, t,
+ A1=match.get("A1", None), A0=match.get("A0", None),
+ b=match.get("rhs", None), type=type,
+ t_=match.get("t_", None))
+ else:
+ new_eqs, new_funcs = _higher_order_to_first_order(eqs, sysorder, t, funcs=funcs,
+ type=type, J=match.get('J', None),
+ f_t=match.get('f(t)', None),
+ P=match.get('P', None), b=match.get('rhs', None))
+
+ if is_transformed:
+ t = match.get('t_', t)
+
+ if not is_higher_order_type2:
+ new_eqs = _select_equations(new_eqs, [f.diff(t) for f in new_funcs])
+
+ sol = None
+
+ # NotImplementedError may be raised when the system may be actually
+ # solvable if it can be just divided into sub-systems
+ try:
+ if not is_higher_order_type2:
+ sol = _strong_component_solver(new_eqs, new_funcs, t)
+ except NotImplementedError:
+ sol = None
+
+ # Dividing the system only when it becomes essential
+ if sol is None:
+ try:
+ sol = _component_solver(new_eqs, new_funcs, t)
+ except NotImplementedError:
+ sol = None
+
+ if sol is None:
+ return sol
+
+ is_second_order_type2 = is_second_order and type == "type2"
+
+ underscores = '__' if is_transformed else '_'
+
+ sol = _select_equations(sol, funcs,
+ key=lambda x: Function(Dummy('{}{}0'.format(x.func.__name__, underscores)))(t))
+
+ if match.get("is_transformed", False):
+ if is_second_order_type2:
+ g_t = match["g(t)"]
+ tau = match["tau"]
+ sol = [Eq(s.lhs, s.rhs.subs(t, tau) * g_t) for s in sol]
+ elif is_euler:
+ t = match['t']
+ tau = match['t_']
+ sol = [s.subs(tau, log(t)) for s in sol]
+ elif is_higher_order_type2:
+ P = match['P']
+ sol_vector = P * Matrix([s.rhs for s in sol])
+ sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)]
+
+ return sol
+
+
+# Returns: List of equations or None
+# If None is returned by this solver, then the system
+# of ODEs cannot be solved directly by dsolve_system.
+def _strong_component_solver(eqs, funcs, t):
+ from sympy.solvers.ode.ode import dsolve, constant_renumber
+
+ match = _classify_linear_system(eqs, funcs, t, is_canon=True)
+ sol = None
+
+ # Assuming that we can't get an implicit system
+ # since we are already canonical equations from
+ # dsolve_system
+ if match:
+ match['t'] = t
+
+ if match.get('is_higher_order', False):
+ sol = _higher_order_ode_solver(match)
+
+ elif match.get('is_linear', False):
+ sol = _linear_ode_solver(match)
+
+ # Note: For now, only linear systems are handled by this function
+ # hence, the match condition is added. This can be removed later.
+ if sol is None and len(eqs) == 1:
+ sol = dsolve(eqs[0], func=funcs[0])
+ variables = Tuple(eqs[0]).free_symbols
+ new_constants = [Dummy() for _ in range(ode_order(eqs[0], funcs[0]))]
+ sol = constant_renumber(sol, variables=variables, newconstants=new_constants)
+ sol = [sol]
+
+ # To add non-linear case here in future
+
+ return sol
+
+
+def _get_funcs_from_canon(eqs):
+ return [eq.lhs.args[0] for eq in eqs]
+
+
+# Returns: List of Equations(a solution)
+def _weak_component_solver(wcc, t):
+
+ # We will divide the systems into sccs
+ # only when the wcc cannot be solved as
+ # a whole
+ eqs = []
+ for scc in wcc:
+ eqs += scc
+ funcs = _get_funcs_from_canon(eqs)
+
+ sol = _strong_component_solver(eqs, funcs, t)
+ if sol:
+ return sol
+
+ sol = []
+
+ for j, scc in enumerate(wcc):
+ eqs = scc
+ funcs = _get_funcs_from_canon(eqs)
+
+ # Substituting solutions for the dependent
+ # variables solved in previous SCC, if any solved.
+ comp_eqs = [eq.subs({s.lhs: s.rhs for s in sol}) for eq in eqs]
+ scc_sol = _strong_component_solver(comp_eqs, funcs, t)
+
+ if scc_sol is None:
+ raise NotImplementedError(filldedent('''
+ The system of ODEs passed cannot be solved by dsolve_system.
+ '''))
+
+ # scc_sol: List of equations
+ # scc_sol is a solution
+ sol += scc_sol
+
+ return sol
+
+
+# Returns: List of Equations(a solution)
+def _component_solver(eqs, funcs, t):
+ components = _component_division(eqs, funcs, t)
+ sol = []
+
+ for wcc in components:
+
+ # wcc_sol: List of Equations
+ sol += _weak_component_solver(wcc, t)
+
+ # sol: List of Equations
+ return sol
+
+
+def _second_order_to_first_order(eqs, funcs, t, type="auto", A1=None,
+ A0=None, b=None, t_=None):
+ r"""
+ Expects the system to be in second order and in canonical form
+
+ Explanation
+ ===========
+
+ Reduces a second order system into a first order one depending on the type of second
+ order system.
+ 1. "type0": If this is passed, then the system will be reduced to first order by
+ introducing dummy variables.
+ 2. "type1": If this is passed, then a particular substitution will be used to reduce the
+ the system into first order.
+ 3. "type2": If this is passed, then the system will be transformed with new dependent
+ variables and independent variables. This transformation is a part of solving
+ the corresponding system of ODEs.
+
+ `A1` and `A0` are the coefficient matrices from the system and it is assumed that the
+ second order system has the form given below:
+
+ .. math::
+ A2 * X'' = A1 * X' + A0 * X + b
+
+ Here, $A2$ is the coefficient matrix for the vector $X''$ and $b$ is the non-homogeneous
+ term.
+
+ Default value for `b` is None but if `A1` and `A0` are passed and `b` is not passed, then the
+ system will be assumed homogeneous.
+
+ """
+ is_a1 = A1 is None
+ is_a0 = A0 is None
+
+ if (type == "type1" and is_a1) or (type == "type2" and is_a0)\
+ or (type == "auto" and (is_a1 or is_a0)):
+ (A2, A1, A0), b = linear_ode_to_matrix(eqs, funcs, t, 2)
+
+ if not A2.is_Identity:
+ raise ValueError(filldedent('''
+ The system must be in its canonical form.
+ '''))
+
+ if type == "auto":
+ match = _match_second_order_type(A1, A0, t)
+ type = match["type_of_equation"]
+ A1 = match.get("A1", None)
+ A0 = match.get("A0", None)
+
+ sys_order = {func: 2 for func in funcs}
+
+ if type == "type1":
+ if b is None:
+ b = zeros(len(eqs))
+ eqs = _second_order_subs_type1(A1, b, funcs, t)
+ sys_order = {func: 1 for func in funcs}
+
+ if type == "type2":
+ if t_ is None:
+ t_ = Symbol("{}_".format(t))
+ t = t_
+ eqs, funcs = _second_order_subs_type2(A0, funcs, t_)
+ sys_order = {func: 2 for func in funcs}
+
+ return _higher_order_to_first_order(eqs, sys_order, t, funcs=funcs)
+
+
+def _higher_order_type2_to_sub_systems(J, f_t, funcs, t, max_order, b=None, P=None):
+
+ # Note: To add a test for this ValueError
+ if J is None or f_t is None or not _matrix_is_constant(J, t):
+ raise ValueError(filldedent('''
+ Correctly input for args 'A' and 'f_t' for Linear, Higher Order,
+ Type 2
+ '''))
+
+ if P is None and b is not None and not b.is_zero_matrix:
+ raise ValueError(filldedent('''
+ Provide the keyword 'P' for matrix P in A = P * J * P-1.
+ '''))
+
+ new_funcs = Matrix([Function(Dummy('{}__0'.format(f.func.__name__)))(t) for f in funcs])
+ new_eqs = new_funcs.diff(t, max_order) - f_t * J * new_funcs
+
+ if b is not None and not b.is_zero_matrix:
+ new_eqs -= P.inv() * b
+
+ new_eqs = canonical_odes(new_eqs, new_funcs, t)[0]
+
+ return new_eqs, new_funcs
+
+
+def _higher_order_to_first_order(eqs, sys_order, t, funcs=None, type="type0", **kwargs):
+ if funcs is None:
+ funcs = sys_order.keys()
+
+ # Standard Cauchy Euler system
+ if type == "type1":
+ t_ = Symbol('{}_'.format(t))
+ new_funcs = [Function(Dummy('{}_'.format(f.func.__name__)))(t_) for f in funcs]
+ max_order = max(sys_order[func] for func in funcs)
+ subs_dict = {func: new_func for func, new_func in zip(funcs, new_funcs)}
+ subs_dict[t] = exp(t_)
+
+ free_function = Function(Dummy())
+
+ def _get_coeffs_from_subs_expression(expr):
+ if isinstance(expr, Subs):
+ free_symbol = expr.args[1][0]
+ term = expr.args[0]
+ return {ode_order(term, free_symbol): 1}
+
+ if isinstance(expr, Mul):
+ coeff = expr.args[0]
+ order = list(_get_coeffs_from_subs_expression(expr.args[1]).keys())[0]
+ return {order: coeff}
+
+ if isinstance(expr, Add):
+ coeffs = {}
+ for arg in expr.args:
+
+ if isinstance(arg, Mul):
+ coeffs.update(_get_coeffs_from_subs_expression(arg))
+
+ else:
+ order = list(_get_coeffs_from_subs_expression(arg).keys())[0]
+ coeffs[order] = 1
+
+ return coeffs
+
+ for o in range(1, max_order + 1):
+ expr = free_function(log(t_)).diff(t_, o)*t_**o
+ coeff_dict = _get_coeffs_from_subs_expression(expr)
+ coeffs = [coeff_dict[order] if order in coeff_dict else 0 for order in range(o + 1)]
+ expr_to_subs = sum(free_function(t_).diff(t_, i) * c for i, c in
+ enumerate(coeffs)) / t**o
+ subs_dict.update({f.diff(t, o): expr_to_subs.subs(free_function(t_), nf)
+ for f, nf in zip(funcs, new_funcs)})
+
+ new_eqs = [eq.subs(subs_dict) for eq in eqs]
+ new_sys_order = {nf: sys_order[f] for f, nf in zip(funcs, new_funcs)}
+
+ new_eqs = canonical_odes(new_eqs, new_funcs, t_)[0]
+
+ return _higher_order_to_first_order(new_eqs, new_sys_order, t_, funcs=new_funcs)
+
+ # Systems of the form: X(n)(t) = f(t)*A*X + b
+ # where X(n)(t) is the nth derivative of the vector of dependent variables
+ # with respect to the independent variable and A is a constant matrix.
+ if type == "type2":
+ J = kwargs.get('J', None)
+ f_t = kwargs.get('f_t', None)
+ b = kwargs.get('b', None)
+ P = kwargs.get('P', None)
+ max_order = max(sys_order[func] for func in funcs)
+
+ return _higher_order_type2_to_sub_systems(J, f_t, funcs, t, max_order, P=P, b=b)
+
+ # Note: To be changed to this after doit option is disabled for default cases
+ # new_sysorder = _get_func_order(new_eqs, new_funcs)
+ #
+ # return _higher_order_to_first_order(new_eqs, new_sysorder, t, funcs=new_funcs)
+
+ new_funcs = []
+
+ for prev_func in funcs:
+ func_name = prev_func.func.__name__
+ func = Function(Dummy('{}_0'.format(func_name)))(t)
+ new_funcs.append(func)
+ subs_dict = {prev_func: func}
+ new_eqs = []
+
+ for i in range(1, sys_order[prev_func]):
+ new_func = Function(Dummy('{}_{}'.format(func_name, i)))(t)
+ subs_dict[prev_func.diff(t, i)] = new_func
+ new_funcs.append(new_func)
+
+ prev_f = subs_dict[prev_func.diff(t, i-1)]
+ new_eq = Eq(prev_f.diff(t), new_func)
+ new_eqs.append(new_eq)
+
+ eqs = [eq.subs(subs_dict) for eq in eqs] + new_eqs
+
+ return eqs, new_funcs
+
+
+def dsolve_system(eqs, funcs=None, t=None, ics=None, doit=False, simplify=True):
+ r"""
+ Solves any(supported) system of Ordinary Differential Equations
+
+ Explanation
+ ===========
+
+ This function takes a system of ODEs as an input, determines if the
+ it is solvable by this function, and returns the solution if found any.
+
+ This function can handle:
+ 1. Linear, First Order, Constant coefficient homogeneous system of ODEs
+ 2. Linear, First Order, Constant coefficient non-homogeneous system of ODEs
+ 3. Linear, First Order, non-constant coefficient homogeneous system of ODEs
+ 4. Linear, First Order, non-constant coefficient non-homogeneous system of ODEs
+ 5. Any implicit system which can be divided into system of ODEs which is of the above 4 forms
+ 6. Any higher order linear system of ODEs that can be reduced to one of the 5 forms of systems described above.
+
+ The types of systems described above are not limited by the number of equations, i.e. this
+ function can solve the above types irrespective of the number of equations in the system passed.
+ But, the bigger the system, the more time it will take to solve the system.
+
+ This function returns a list of solutions. Each solution is a list of equations where LHS is
+ the dependent variable and RHS is an expression in terms of the independent variable.
+
+ Among the non constant coefficient types, not all the systems are solvable by this function. Only
+ those which have either a coefficient matrix with a commutative antiderivative or those systems which
+ may be divided further so that the divided systems may have coefficient matrix with commutative antiderivative.
+
+ Parameters
+ ==========
+
+ eqs : List
+ system of ODEs to be solved
+ funcs : List or None
+ List of dependent variables that make up the system of ODEs
+ t : Symbol or None
+ Independent variable in the system of ODEs
+ ics : Dict or None
+ Set of initial boundary/conditions for the system of ODEs
+ doit : Boolean
+ Evaluate the solutions if True. Default value is True. Can be
+ set to false if the integral evaluation takes too much time and/or
+ is not required.
+ simplify: Boolean
+ Simplify the solutions for the systems. Default value is True.
+ Can be set to false if simplification takes too much time and/or
+ is not required.
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, Eq, Function
+ >>> from sympy.solvers.ode.systems import dsolve_system
+ >>> f, g = symbols("f g", cls=Function)
+ >>> x = symbols("x")
+
+ >>> eqs = [Eq(f(x).diff(x), g(x)), Eq(g(x).diff(x), f(x))]
+ >>> dsolve_system(eqs)
+ [[Eq(f(x), -C1*exp(-x) + C2*exp(x)), Eq(g(x), C1*exp(-x) + C2*exp(x))]]
+
+ You can also pass the initial conditions for the system of ODEs:
+
+ >>> dsolve_system(eqs, ics={f(0): 1, g(0): 0})
+ [[Eq(f(x), exp(x)/2 + exp(-x)/2), Eq(g(x), exp(x)/2 - exp(-x)/2)]]
+
+ Optionally, you can pass the dependent variables and the independent
+ variable for which the system is to be solved:
+
+ >>> funcs = [f(x), g(x)]
+ >>> dsolve_system(eqs, funcs=funcs, t=x)
+ [[Eq(f(x), -C1*exp(-x) + C2*exp(x)), Eq(g(x), C1*exp(-x) + C2*exp(x))]]
+
+ Lets look at an implicit system of ODEs:
+
+ >>> eqs = [Eq(f(x).diff(x)**2, g(x)**2), Eq(g(x).diff(x), g(x))]
+ >>> dsolve_system(eqs)
+ [[Eq(f(x), C1 - C2*exp(x)), Eq(g(x), C2*exp(x))], [Eq(f(x), C1 + C2*exp(x)), Eq(g(x), C2*exp(x))]]
+
+ Returns
+ =======
+
+ List of List of Equations
+
+ Raises
+ ======
+
+ NotImplementedError
+ When the system of ODEs is not solvable by this function.
+ ValueError
+ When the parameters passed are not in the required form.
+
+ """
+ from sympy.solvers.ode.ode import solve_ics, _extract_funcs, constant_renumber
+
+ if not iterable(eqs):
+ raise ValueError(filldedent('''
+ List of equations should be passed. The input is not valid.
+ '''))
+
+ eqs = _preprocess_eqs(eqs)
+
+ if funcs is not None and not isinstance(funcs, list):
+ raise ValueError(filldedent('''
+ Input to the funcs should be a list of functions.
+ '''))
+
+ if funcs is None:
+ funcs = _extract_funcs(eqs)
+
+ if any(len(func.args) != 1 for func in funcs):
+ raise ValueError(filldedent('''
+ dsolve_system can solve a system of ODEs with only one independent
+ variable.
+ '''))
+
+ if len(eqs) != len(funcs):
+ raise ValueError(filldedent('''
+ Number of equations and number of functions do not match
+ '''))
+
+ if t is not None and not isinstance(t, Symbol):
+ raise ValueError(filldedent('''
+ The independent variable must be of type Symbol
+ '''))
+
+ if t is None:
+ t = list(list(eqs[0].atoms(Derivative))[0].atoms(Symbol))[0]
+
+ sols = []
+ canon_eqs = canonical_odes(eqs, funcs, t)
+
+ for canon_eq in canon_eqs:
+ try:
+ sol = _strong_component_solver(canon_eq, funcs, t)
+ except NotImplementedError:
+ sol = None
+
+ if sol is None:
+ sol = _component_solver(canon_eq, funcs, t)
+
+ sols.append(sol)
+
+ if sols:
+ final_sols = []
+ variables = Tuple(*eqs).free_symbols
+
+ for sol in sols:
+
+ sol = _select_equations(sol, funcs)
+ sol = constant_renumber(sol, variables=variables)
+
+ if ics:
+ constants = Tuple(*sol).free_symbols - variables
+ solved_constants = solve_ics(sol, funcs, constants, ics)
+ sol = [s.subs(solved_constants) for s in sol]
+
+ if simplify:
+ constants = Tuple(*sol).free_symbols - variables
+ sol = simpsol(sol, [t], constants, doit=doit)
+
+ final_sols.append(sol)
+
+ sols = final_sols
+
+ return sols
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__init__.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5d01f0b3808707906460d42349dbabd79b038fbc
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/test_ode.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/test_ode.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b3153099e50292d335ac179d9f307420524132f0
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/test_ode.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/test_riccati.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/test_riccati.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..305c41fa62e998c4fd65b6d987dc0b399b30ac5e
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/test_riccati.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/test_systems.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/test_systems.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5b445125396a6d2a2f7b88c55ad29dead3660e6b
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/__pycache__/test_systems.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_lie_group.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_lie_group.py
new file mode 100644
index 0000000000000000000000000000000000000000..153d30ff563773819e49c989f447c1ec7962169b
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_lie_group.py
@@ -0,0 +1,152 @@
+from sympy.core.function import Function
+from sympy.core.numbers import Rational
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (atan, sin, tan)
+
+from sympy.solvers.ode import (classify_ode, checkinfsol, dsolve, infinitesimals)
+
+from sympy.solvers.ode.subscheck import checkodesol
+
+from sympy.testing.pytest import XFAIL
+
+
+C1 = Symbol('C1')
+x, y = symbols("x y")
+f = Function('f')
+xi = Function('xi')
+eta = Function('eta')
+
+
+def test_heuristic1():
+ a, b, c, a4, a3, a2, a1, a0 = symbols("a b c a4 a3 a2 a1 a0")
+ df = f(x).diff(x)
+ eq = Eq(df, x**2*f(x))
+ eq1 = f(x).diff(x) + a*f(x) - c*exp(b*x)
+ eq2 = f(x).diff(x) + 2*x*f(x) - x*exp(-x**2)
+ eq3 = (1 + 2*x)*df + 2 - 4*exp(-f(x))
+ eq4 = f(x).diff(x) - (a4*x**4 + a3*x**3 + a2*x**2 + a1*x + a0)**Rational(-1, 2)
+ eq5 = x**2*df - f(x) + x**2*exp(x - (1/x))
+ eqlist = [eq, eq1, eq2, eq3, eq4, eq5]
+
+ i = infinitesimals(eq, hint='abaco1_simple')
+ assert i == [{eta(x, f(x)): exp(x**3/3), xi(x, f(x)): 0},
+ {eta(x, f(x)): f(x), xi(x, f(x)): 0},
+ {eta(x, f(x)): 0, xi(x, f(x)): x**(-2)}]
+ i1 = infinitesimals(eq1, hint='abaco1_simple')
+ assert i1 == [{eta(x, f(x)): exp(-a*x), xi(x, f(x)): 0}]
+ i2 = infinitesimals(eq2, hint='abaco1_simple')
+ assert i2 == [{eta(x, f(x)): exp(-x**2), xi(x, f(x)): 0}]
+ i3 = infinitesimals(eq3, hint='abaco1_simple')
+ assert i3 == [{eta(x, f(x)): 0, xi(x, f(x)): 2*x + 1},
+ {eta(x, f(x)): 0, xi(x, f(x)): 1/(exp(f(x)) - 2)}]
+ i4 = infinitesimals(eq4, hint='abaco1_simple')
+ assert i4 == [{eta(x, f(x)): 1, xi(x, f(x)): 0},
+ {eta(x, f(x)): 0,
+ xi(x, f(x)): sqrt(a0 + a1*x + a2*x**2 + a3*x**3 + a4*x**4)}]
+ i5 = infinitesimals(eq5, hint='abaco1_simple')
+ assert i5 == [{xi(x, f(x)): 0, eta(x, f(x)): exp(-1/x)}]
+
+ ilist = [i, i1, i2, i3, i4, i5]
+ for eq, i in (zip(eqlist, ilist)):
+ check = checkinfsol(eq, i)
+ assert check[0]
+
+ # This ODE can be solved by the Lie Group method, when there are
+ # better assumptions
+ eq6 = df - (f(x)/x)*(x*log(x**2/f(x)) + 2)
+ i = infinitesimals(eq6, hint='abaco1_product')
+ assert i == [{eta(x, f(x)): f(x)*exp(-x), xi(x, f(x)): 0}]
+ assert checkinfsol(eq6, i)[0]
+
+ eq7 = x*(f(x).diff(x)) + 1 - f(x)**2
+ i = infinitesimals(eq7, hint='chi')
+ assert checkinfsol(eq7, i)[0]
+
+
+def test_heuristic3():
+ a, b = symbols("a b")
+ df = f(x).diff(x)
+
+ eq = x**2*df + x*f(x) + f(x)**2 + x**2
+ i = infinitesimals(eq, hint='bivariate')
+ assert i == [{eta(x, f(x)): f(x), xi(x, f(x)): x}]
+ assert checkinfsol(eq, i)[0]
+
+ eq = x**2*(-f(x)**2 + df)- a*x**2*f(x) + 2 - a*x
+ i = infinitesimals(eq, hint='bivariate')
+ assert checkinfsol(eq, i)[0]
+
+
+def test_heuristic_function_sum():
+ eq = f(x).diff(x) - (3*(1 + x**2/f(x)**2)*atan(f(x)/x) + (1 - 2*f(x))/x +
+ (1 - 3*f(x))*(x/f(x)**2))
+ i = infinitesimals(eq, hint='function_sum')
+ assert i == [{eta(x, f(x)): f(x)**(-2) + x**(-2), xi(x, f(x)): 0}]
+ assert checkinfsol(eq, i)[0]
+
+
+def test_heuristic_abaco2_similar():
+ a, b = symbols("a b")
+ F = Function('F')
+ eq = f(x).diff(x) - F(a*x + b*f(x))
+ i = infinitesimals(eq, hint='abaco2_similar')
+ assert i == [{eta(x, f(x)): -a/b, xi(x, f(x)): 1}]
+ assert checkinfsol(eq, i)[0]
+
+ eq = f(x).diff(x) - (f(x)**2 / (sin(f(x) - x) - x**2 + 2*x*f(x)))
+ i = infinitesimals(eq, hint='abaco2_similar')
+ assert i == [{eta(x, f(x)): f(x)**2, xi(x, f(x)): f(x)**2}]
+ assert checkinfsol(eq, i)[0]
+
+
+def test_heuristic_abaco2_unique_unknown():
+
+ a, b = symbols("a b")
+ F = Function('F')
+ eq = f(x).diff(x) - x**(a - 1)*(f(x)**(1 - b))*F(x**a/a + f(x)**b/b)
+ i = infinitesimals(eq, hint='abaco2_unique_unknown')
+ assert i == [{eta(x, f(x)): -f(x)*f(x)**(-b), xi(x, f(x)): x*x**(-a)}]
+ assert checkinfsol(eq, i)[0]
+
+ eq = f(x).diff(x) + tan(F(x**2 + f(x)**2) + atan(x/f(x)))
+ i = infinitesimals(eq, hint='abaco2_unique_unknown')
+ assert i == [{eta(x, f(x)): x, xi(x, f(x)): -f(x)}]
+ assert checkinfsol(eq, i)[0]
+
+ eq = (x*f(x).diff(x) + f(x) + 2*x)**2 -4*x*f(x) -4*x**2 -4*a
+ i = infinitesimals(eq, hint='abaco2_unique_unknown')
+ assert checkinfsol(eq, i)[0]
+
+
+def test_heuristic_linear():
+ a, b, m, n = symbols("a b m n")
+
+ eq = x**(n*(m + 1) - m)*(f(x).diff(x)) - a*f(x)**n -b*x**(n*(m + 1))
+ i = infinitesimals(eq, hint='linear')
+ assert checkinfsol(eq, i)[0]
+
+
+@XFAIL
+def test_kamke():
+ a, b, alpha, c = symbols("a b alpha c")
+ eq = x**2*(a*f(x)**2+(f(x).diff(x))) + b*x**alpha + c
+ i = infinitesimals(eq, hint='sum_function') # XFAIL
+ assert checkinfsol(eq, i)[0]
+
+
+def test_user_infinitesimals():
+ x = Symbol("x") # assuming x is real generates an error
+ eq = x*(f(x).diff(x)) + 1 - f(x)**2
+ sol = Eq(f(x), (C1 + x**2)/(C1 - x**2))
+ infinitesimals = {'xi':sqrt(f(x) - 1)/sqrt(f(x) + 1), 'eta':0}
+ assert dsolve(eq, hint='lie_group', **infinitesimals) == sol
+ assert checkodesol(eq, sol) == (True, 0)
+
+
+@XFAIL
+def test_lie_group_issue15219():
+ eqn = exp(f(x).diff(x)-f(x))
+ assert 'lie_group' not in classify_ode(eqn, f(x))
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_ode.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_ode.py
new file mode 100644
index 0000000000000000000000000000000000000000..547b8e425c345a19b0bede4625b02779e34d7852
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_ode.py
@@ -0,0 +1,1096 @@
+from sympy.core.function import (Derivative, Function, Subs, diff)
+from sympy.core.numbers import (E, I, Rational, 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 (im, re)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import acosh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (atan2, cos, sin, tan)
+from sympy.integrals.integrals import Integral
+from sympy.polys.polytools import Poly
+from sympy.series.order import O
+from sympy.simplify.radsimp import collect
+
+from sympy.solvers.ode import (classify_ode,
+ homogeneous_order, dsolve)
+
+from sympy.solvers.ode.subscheck import checkodesol
+from sympy.solvers.ode.ode import (classify_sysode,
+ constant_renumber, constantsimp, get_numbered_constants, solve_ics)
+
+from sympy.solvers.ode.nonhomogeneous import _undetermined_coefficients_match
+from sympy.solvers.ode.single import LinearCoefficients
+from sympy.solvers.deutils import ode_order
+from sympy.testing.pytest import XFAIL, raises, slow
+from sympy.utilities.misc import filldedent
+
+
+C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 = symbols('C0:11')
+u, x, y, z = symbols('u,x:z', real=True)
+f = Function('f')
+g = Function('g')
+h = Function('h')
+
+# Note: Examples which were specifically testing Single ODE solver are moved to test_single.py
+# and all the system of ode examples are moved to test_systems.py
+# Note: the tests below may fail (but still be correct) if ODE solver,
+# the integral engine, solve(), or even simplify() changes. Also, in
+# differently formatted solutions, the arbitrary constants might not be
+# equal. Using specific hints in tests can help to avoid this.
+
+# Tests of order higher than 1 should run the solutions through
+# constant_renumber because it will normalize it (constant_renumber causes
+# dsolve() to return different results on different machines)
+
+
+def test_get_numbered_constants():
+ with raises(ValueError):
+ get_numbered_constants(None)
+
+
+def test_dsolve_all_hint():
+ eq = f(x).diff(x)
+ output = dsolve(eq, hint='all')
+
+ # Match the Dummy variables:
+ sol1 = output['separable_Integral']
+ _y = sol1.lhs.args[1][0]
+ sol1 = output['1st_homogeneous_coeff_subs_dep_div_indep_Integral']
+ _u1 = sol1.rhs.args[1].args[1][0]
+
+ expected = {'Bernoulli_Integral': Eq(f(x), C1 + Integral(0, x)),
+ '1st_homogeneous_coeff_best': Eq(f(x), C1),
+ 'Bernoulli': Eq(f(x), C1),
+ 'nth_algebraic': Eq(f(x), C1),
+ 'nth_linear_euler_eq_homogeneous': Eq(f(x), C1),
+ 'nth_linear_constant_coeff_homogeneous': Eq(f(x), C1),
+ 'separable': Eq(f(x), C1),
+ '1st_homogeneous_coeff_subs_indep_div_dep': Eq(f(x), C1),
+ 'nth_algebraic_Integral': Eq(f(x), C1),
+ '1st_linear': Eq(f(x), C1),
+ '1st_linear_Integral': Eq(f(x), C1 + Integral(0, x)),
+ '1st_exact': Eq(f(x), C1),
+ '1st_exact_Integral': Eq(Subs(Integral(0, x) + Integral(1, _y), _y, f(x)), C1),
+ 'lie_group': Eq(f(x), C1),
+ '1st_homogeneous_coeff_subs_dep_div_indep': Eq(f(x), C1),
+ '1st_homogeneous_coeff_subs_dep_div_indep_Integral': Eq(log(x), C1 + Integral(-1/_u1, (_u1, f(x)/x))),
+ '1st_power_series': Eq(f(x), C1),
+ 'separable_Integral': Eq(Integral(1, (_y, f(x))), C1 + Integral(0, x)),
+ '1st_homogeneous_coeff_subs_indep_div_dep_Integral': Eq(f(x), C1),
+ 'best': Eq(f(x), C1),
+ 'best_hint': 'nth_algebraic',
+ 'default': 'nth_algebraic',
+ 'order': 1}
+ assert output == expected
+
+ assert dsolve(eq, hint='best') == Eq(f(x), C1)
+
+
+def test_dsolve_ics():
+ # Maybe this should just use one of the solutions instead of raising...
+ with raises(NotImplementedError):
+ dsolve(f(x).diff(x) - sqrt(f(x)), ics={f(1):1})
+
+
+@slow
+def test_dsolve_options():
+ eq = x*f(x).diff(x) + f(x)
+ a = dsolve(eq, hint='all')
+ b = dsolve(eq, hint='all', simplify=False)
+ c = dsolve(eq, hint='all_Integral')
+ keys = ['1st_exact', '1st_exact_Integral', '1st_homogeneous_coeff_best',
+ '1st_homogeneous_coeff_subs_dep_div_indep',
+ '1st_homogeneous_coeff_subs_dep_div_indep_Integral',
+ '1st_homogeneous_coeff_subs_indep_div_dep',
+ '1st_homogeneous_coeff_subs_indep_div_dep_Integral', '1st_linear',
+ '1st_linear_Integral', 'Bernoulli', 'Bernoulli_Integral',
+ 'almost_linear', 'almost_linear_Integral', 'best', 'best_hint',
+ 'default', 'factorable', 'lie_group',
+ 'nth_linear_euler_eq_homogeneous', 'order',
+ 'separable', 'separable_Integral']
+ Integral_keys = ['1st_exact_Integral',
+ '1st_homogeneous_coeff_subs_dep_div_indep_Integral',
+ '1st_homogeneous_coeff_subs_indep_div_dep_Integral', '1st_linear_Integral',
+ 'Bernoulli_Integral', 'almost_linear_Integral', 'best', 'best_hint', 'default',
+ 'factorable', 'nth_linear_euler_eq_homogeneous',
+ 'order', 'separable_Integral']
+ assert sorted(a.keys()) == keys
+ assert a['order'] == ode_order(eq, f(x))
+ assert a['best'] == Eq(f(x), C1/x)
+ assert dsolve(eq, hint='best') == Eq(f(x), C1/x)
+ assert a['default'] == 'factorable'
+ assert a['best_hint'] == 'factorable'
+ assert not a['1st_exact'].has(Integral)
+ assert not a['separable'].has(Integral)
+ assert not a['1st_homogeneous_coeff_best'].has(Integral)
+ assert not a['1st_homogeneous_coeff_subs_dep_div_indep'].has(Integral)
+ assert not a['1st_homogeneous_coeff_subs_indep_div_dep'].has(Integral)
+ assert not a['1st_linear'].has(Integral)
+ assert a['1st_linear_Integral'].has(Integral)
+ assert a['1st_exact_Integral'].has(Integral)
+ assert a['1st_homogeneous_coeff_subs_dep_div_indep_Integral'].has(Integral)
+ assert a['1st_homogeneous_coeff_subs_indep_div_dep_Integral'].has(Integral)
+ assert a['separable_Integral'].has(Integral)
+ assert sorted(b.keys()) == keys
+ assert b['order'] == ode_order(eq, f(x))
+ assert b['best'] == Eq(f(x), C1/x)
+ assert dsolve(eq, hint='best', simplify=False) == Eq(f(x), C1/x)
+ assert b['default'] == 'factorable'
+ assert b['best_hint'] == 'factorable'
+ assert a['separable'] != b['separable']
+ assert a['1st_homogeneous_coeff_subs_dep_div_indep'] != \
+ b['1st_homogeneous_coeff_subs_dep_div_indep']
+ assert a['1st_homogeneous_coeff_subs_indep_div_dep'] != \
+ b['1st_homogeneous_coeff_subs_indep_div_dep']
+ assert not b['1st_exact'].has(Integral)
+ assert not b['separable'].has(Integral)
+ assert not b['1st_homogeneous_coeff_best'].has(Integral)
+ assert not b['1st_homogeneous_coeff_subs_dep_div_indep'].has(Integral)
+ assert not b['1st_homogeneous_coeff_subs_indep_div_dep'].has(Integral)
+ assert not b['1st_linear'].has(Integral)
+ assert b['1st_linear_Integral'].has(Integral)
+ assert b['1st_exact_Integral'].has(Integral)
+ assert b['1st_homogeneous_coeff_subs_dep_div_indep_Integral'].has(Integral)
+ assert b['1st_homogeneous_coeff_subs_indep_div_dep_Integral'].has(Integral)
+ assert b['separable_Integral'].has(Integral)
+ assert sorted(c.keys()) == Integral_keys
+ raises(ValueError, lambda: dsolve(eq, hint='notarealhint'))
+ raises(ValueError, lambda: dsolve(eq, hint='Liouville'))
+ assert dsolve(f(x).diff(x) - 1/f(x)**2, hint='all')['best'] == \
+ dsolve(f(x).diff(x) - 1/f(x)**2, hint='best')
+ assert dsolve(f(x) + f(x).diff(x) + sin(x).diff(x) + 1, f(x),
+ hint="1st_linear_Integral") == \
+ Eq(f(x), (C1 + Integral((-sin(x).diff(x) - 1)*
+ exp(Integral(1, x)), x))*exp(-Integral(1, x)))
+
+
+def test_classify_ode():
+ assert classify_ode(f(x).diff(x, 2), f(x)) == \
+ (
+ 'nth_algebraic',
+ 'nth_linear_constant_coeff_homogeneous',
+ 'nth_linear_euler_eq_homogeneous',
+ 'Liouville',
+ '2nd_power_series_ordinary',
+ 'nth_algebraic_Integral',
+ 'Liouville_Integral',
+ )
+ assert classify_ode(f(x), f(x)) == ('nth_algebraic', 'nth_algebraic_Integral')
+ assert classify_ode(Eq(f(x).diff(x), 0), f(x)) == (
+ 'nth_algebraic',
+ 'separable',
+ '1st_exact',
+ '1st_linear',
+ 'Bernoulli',
+ '1st_homogeneous_coeff_best',
+ '1st_homogeneous_coeff_subs_indep_div_dep',
+ '1st_homogeneous_coeff_subs_dep_div_indep',
+ '1st_power_series', 'lie_group',
+ 'nth_linear_constant_coeff_homogeneous',
+ 'nth_linear_euler_eq_homogeneous',
+ 'nth_algebraic_Integral',
+ 'separable_Integral',
+ '1st_exact_Integral',
+ '1st_linear_Integral',
+ 'Bernoulli_Integral',
+ '1st_homogeneous_coeff_subs_indep_div_dep_Integral',
+ '1st_homogeneous_coeff_subs_dep_div_indep_Integral')
+ assert classify_ode(f(x).diff(x)**2, f(x)) == ('factorable',
+ 'nth_algebraic',
+ 'separable',
+ '1st_exact',
+ '1st_linear',
+ 'Bernoulli',
+ '1st_homogeneous_coeff_best',
+ '1st_homogeneous_coeff_subs_indep_div_dep',
+ '1st_homogeneous_coeff_subs_dep_div_indep',
+ '1st_power_series',
+ 'lie_group',
+ 'nth_linear_euler_eq_homogeneous',
+ 'nth_algebraic_Integral',
+ 'separable_Integral',
+ '1st_exact_Integral',
+ '1st_linear_Integral',
+ 'Bernoulli_Integral',
+ '1st_homogeneous_coeff_subs_indep_div_dep_Integral',
+ '1st_homogeneous_coeff_subs_dep_div_indep_Integral')
+ # issue 4749: f(x) should be cleared from highest derivative before classifying
+ a = classify_ode(Eq(f(x).diff(x) + f(x), x), f(x))
+ b = classify_ode(f(x).diff(x)*f(x) + f(x)*f(x) - x*f(x), f(x))
+ c = classify_ode(f(x).diff(x)/f(x) + f(x)/f(x) - x/f(x), f(x))
+ assert a == ('1st_exact',
+ '1st_linear',
+ 'Bernoulli',
+ 'almost_linear',
+ '1st_power_series', "lie_group",
+ 'nth_linear_constant_coeff_undetermined_coefficients',
+ 'nth_linear_constant_coeff_variation_of_parameters',
+ '1st_exact_Integral',
+ '1st_linear_Integral',
+ 'Bernoulli_Integral',
+ 'almost_linear_Integral',
+ 'nth_linear_constant_coeff_variation_of_parameters_Integral')
+ assert b == ('factorable',
+ '1st_linear',
+ 'Bernoulli',
+ '1st_power_series',
+ 'lie_group',
+ 'nth_linear_constant_coeff_undetermined_coefficients',
+ 'nth_linear_constant_coeff_variation_of_parameters',
+ '1st_linear_Integral',
+ 'Bernoulli_Integral',
+ 'nth_linear_constant_coeff_variation_of_parameters_Integral')
+ assert c == ('factorable',
+ '1st_linear',
+ 'Bernoulli',
+ '1st_power_series',
+ 'lie_group',
+ 'nth_linear_constant_coeff_undetermined_coefficients',
+ 'nth_linear_constant_coeff_variation_of_parameters',
+ '1st_linear_Integral',
+ 'Bernoulli_Integral',
+ 'nth_linear_constant_coeff_variation_of_parameters_Integral')
+
+ assert classify_ode(
+ 2*x*f(x)*f(x).diff(x) + (1 + x)*f(x)**2 - exp(x), f(x)
+ ) == ('factorable', '1st_exact', 'Bernoulli', 'almost_linear', 'lie_group',
+ '1st_exact_Integral', 'Bernoulli_Integral', 'almost_linear_Integral')
+ assert 'Riccati_special_minus2' in \
+ classify_ode(2*f(x).diff(x) + f(x)**2 - f(x)/x + 3*x**(-2), f(x))
+ raises(ValueError, lambda: classify_ode(x + f(x, y).diff(x).diff(
+ y), f(x, y)))
+ # issue 5176
+ k = Symbol('k')
+ assert classify_ode(f(x).diff(x)/(k*f(x) + k*x*f(x)) + 2*f(x)/(k*f(x) +
+ k*x*f(x)) + x*f(x).diff(x)/(k*f(x) + k*x*f(x)) + z, f(x)) == \
+ ('factorable', 'separable', '1st_exact', '1st_linear', 'Bernoulli',
+ '1st_power_series', 'lie_group', 'separable_Integral', '1st_exact_Integral',
+ '1st_linear_Integral', 'Bernoulli_Integral')
+ # preprocessing
+ ans = ('factorable', 'nth_algebraic', 'separable', '1st_exact', '1st_linear', 'Bernoulli',
+ '1st_homogeneous_coeff_best',
+ '1st_homogeneous_coeff_subs_indep_div_dep',
+ '1st_homogeneous_coeff_subs_dep_div_indep',
+ '1st_power_series', 'lie_group',
+ 'nth_linear_constant_coeff_undetermined_coefficients',
+ 'nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients',
+ 'nth_linear_constant_coeff_variation_of_parameters',
+ 'nth_linear_euler_eq_nonhomogeneous_variation_of_parameters',
+ 'nth_algebraic_Integral',
+ 'separable_Integral', '1st_exact_Integral',
+ '1st_linear_Integral',
+ 'Bernoulli_Integral',
+ '1st_homogeneous_coeff_subs_indep_div_dep_Integral',
+ '1st_homogeneous_coeff_subs_dep_div_indep_Integral',
+ 'nth_linear_constant_coeff_variation_of_parameters_Integral',
+ 'nth_linear_euler_eq_nonhomogeneous_variation_of_parameters_Integral')
+ # w/o f(x) given
+ assert classify_ode(diff(f(x) + x, x) + diff(f(x), x)) == ans
+ # w/ f(x) and prep=True
+ assert classify_ode(diff(f(x) + x, x) + diff(f(x), x), f(x),
+ prep=True) == ans
+
+ assert classify_ode(Eq(2*x**3*f(x).diff(x), 0), f(x)) == \
+ ('factorable', 'nth_algebraic', 'separable', '1st_exact',
+ '1st_linear', 'Bernoulli', '1st_power_series',
+ 'lie_group', 'nth_linear_euler_eq_homogeneous',
+ 'nth_algebraic_Integral', 'separable_Integral', '1st_exact_Integral',
+ '1st_linear_Integral', 'Bernoulli_Integral')
+
+
+ assert classify_ode(Eq(2*f(x)**3*f(x).diff(x), 0), f(x)) == \
+ ('factorable', 'nth_algebraic', 'separable', '1st_exact', '1st_linear',
+ 'Bernoulli', '1st_power_series', 'lie_group', 'nth_algebraic_Integral',
+ 'separable_Integral', '1st_exact_Integral', '1st_linear_Integral',
+ 'Bernoulli_Integral')
+ # test issue 13864
+ assert classify_ode(Eq(diff(f(x), x) - f(x)**x, 0), f(x)) == \
+ ('1st_power_series', 'lie_group')
+ assert isinstance(classify_ode(Eq(f(x), 5), f(x), dict=True), dict)
+
+ #This is for new behavior of classify_ode when called internally with default, It should
+ # return the first hint which matches therefore, 'ordered_hints' key will not be there.
+ assert sorted(classify_ode(Eq(f(x).diff(x), 0), f(x), dict=True).keys()) == \
+ ['default', 'nth_linear_constant_coeff_homogeneous', 'order']
+ a = classify_ode(2*x*f(x)*f(x).diff(x) + (1 + x)*f(x)**2 - exp(x), f(x), dict=True, hint='Bernoulli')
+ assert sorted(a.keys()) == ['Bernoulli', 'Bernoulli_Integral', 'default', 'order', 'ordered_hints']
+
+ # test issue 22155
+ a = classify_ode(f(x).diff(x) - exp(f(x) - x), f(x))
+ assert a == ('separable',
+ '1st_exact', '1st_power_series',
+ 'lie_group', 'separable_Integral',
+ '1st_exact_Integral')
+
+
+def test_classify_ode_ics():
+ # Dummy
+ eq = f(x).diff(x, x) - f(x)
+
+ # Not f(0) or f'(0)
+ ics = {x: 1}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+
+ ############################
+ # f(0) type (AppliedUndef) #
+ ############################
+
+
+ # Wrong function
+ ics = {g(0): 1}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # Contains x
+ ics = {f(x): 1}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # Too many args
+ ics = {f(0, 0): 1}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # point contains x
+ ics = {f(0): f(x)}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # Does not raise
+ ics = {f(0): f(0)}
+ classify_ode(eq, f(x), ics=ics)
+
+ # Does not raise
+ ics = {f(0): 1}
+ classify_ode(eq, f(x), ics=ics)
+
+
+ #####################
+ # f'(0) type (Subs) #
+ #####################
+
+ # Wrong function
+ ics = {g(x).diff(x).subs(x, 0): 1}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # Contains x
+ ics = {f(y).diff(y).subs(y, x): 1}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # Wrong variable
+ ics = {f(y).diff(y).subs(y, 0): 1}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # Too many args
+ ics = {f(x, y).diff(x).subs(x, 0): 1}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # Derivative wrt wrong vars
+ ics = {Derivative(f(x), x, y).subs(x, 0): 1}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # point contains x
+ ics = {f(x).diff(x).subs(x, 0): f(x)}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # Does not raise
+ ics = {f(x).diff(x).subs(x, 0): f(x).diff(x).subs(x, 0)}
+ classify_ode(eq, f(x), ics=ics)
+
+ # Does not raise
+ ics = {f(x).diff(x).subs(x, 0): 1}
+ classify_ode(eq, f(x), ics=ics)
+
+ ###########################
+ # f'(y) type (Derivative) #
+ ###########################
+
+ # Wrong function
+ ics = {g(x).diff(x).subs(x, y): 1}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # Contains x
+ ics = {f(y).diff(y).subs(y, x): 1}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # Too many args
+ ics = {f(x, y).diff(x).subs(x, y): 1}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # Derivative wrt wrong vars
+ ics = {Derivative(f(x), x, z).subs(x, y): 1}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # point contains x
+ ics = {f(x).diff(x).subs(x, y): f(x)}
+ raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+ # Does not raise
+ ics = {f(x).diff(x).subs(x, 0): f(0)}
+ classify_ode(eq, f(x), ics=ics)
+
+ # Does not raise
+ ics = {f(x).diff(x).subs(x, y): 1}
+ classify_ode(eq, f(x), ics=ics)
+
+def test_classify_sysode():
+ # Here x is assumed to be x(t) and y as y(t) for simplicity.
+ # Similarly diff(x,t) and diff(y,y) is assumed to be x1 and y1 respectively.
+ k, l, m, n = symbols('k, l, m, n', Integer=True)
+ k1, k2, k3, l1, l2, l3, m1, m2, m3 = symbols('k1, k2, k3, l1, l2, l3, m1, m2, m3', Integer=True)
+ P, Q, R, p, q, r = symbols('P, Q, R, p, q, r', cls=Function)
+ P1, P2, P3, Q1, Q2, R1, R2 = symbols('P1, P2, P3, Q1, Q2, R1, R2', cls=Function)
+ x, y, z = symbols('x, y, z', cls=Function)
+ t = symbols('t')
+ x1 = diff(x(t),t) ; y1 = diff(y(t),t) ;
+
+ eq6 = (Eq(x1, exp(k*x(t))*P(x(t),y(t))), Eq(y1,r(y(t))*P(x(t),y(t))))
+ sol6 = {'no_of_equation': 2, 'func_coeff': {(0, x(t), 0): 0, (1, x(t), 1): 0, (0, x(t), 1): 1, (1, y(t), 0): 0, \
+ (1, x(t), 0): 0, (0, y(t), 1): 0, (0, y(t), 0): 0, (1, y(t), 1): 1}, 'type_of_equation': 'type2', 'func': \
+ [x(t), y(t)], 'is_linear': False, 'eq': [-P(x(t), y(t))*exp(k*x(t)) + Derivative(x(t), t), -P(x(t), \
+ y(t))*r(y(t)) + Derivative(y(t), t)], 'order': {y(t): 1, x(t): 1}}
+ assert classify_sysode(eq6) == sol6
+
+ eq7 = (Eq(x1, x(t)**2+y(t)/x(t)), Eq(y1, x(t)/y(t)))
+ sol7 = {'no_of_equation': 2, 'func_coeff': {(0, x(t), 0): 0, (1, x(t), 1): 0, (0, x(t), 1): 1, (1, y(t), 0): 0, \
+ (1, x(t), 0): -1/y(t), (0, y(t), 1): 0, (0, y(t), 0): -1/x(t), (1, y(t), 1): 1}, 'type_of_equation': 'type3', \
+ 'func': [x(t), y(t)], 'is_linear': False, 'eq': [-x(t)**2 + Derivative(x(t), t) - y(t)/x(t), -x(t)/y(t) + \
+ Derivative(y(t), t)], 'order': {y(t): 1, x(t): 1}}
+ assert classify_sysode(eq7) == sol7
+
+ eq8 = (Eq(x1, P1(x(t))*Q1(y(t))*R(x(t),y(t),t)), Eq(y1, P1(x(t))*Q1(y(t))*R(x(t),y(t),t)))
+ sol8 = {'func': [x(t), y(t)], 'is_linear': False, 'type_of_equation': 'type4', 'eq': \
+ [-P1(x(t))*Q1(y(t))*R(x(t), y(t), t) + Derivative(x(t), t), -P1(x(t))*Q1(y(t))*R(x(t), y(t), t) + \
+ Derivative(y(t), t)], 'func_coeff': {(0, y(t), 1): 0, (1, y(t), 1): 1, (1, x(t), 1): 0, (0, y(t), 0): 0, \
+ (1, x(t), 0): 0, (0, x(t), 0): 0, (1, y(t), 0): 0, (0, x(t), 1): 1}, 'order': {y(t): 1, x(t): 1}, 'no_of_equation': 2}
+ assert classify_sysode(eq8) == sol8
+
+ eq11 = (Eq(x1,x(t)*y(t)**3), Eq(y1,y(t)**5))
+ sol11 = {'no_of_equation': 2, 'func_coeff': {(0, x(t), 0): -y(t)**3, (1, x(t), 1): 0, (0, x(t), 1): 1, \
+ (1, y(t), 0): 0, (1, x(t), 0): 0, (0, y(t), 1): 0, (0, y(t), 0): 0, (1, y(t), 1): 1}, 'type_of_equation': \
+ 'type1', 'func': [x(t), y(t)], 'is_linear': False, 'eq': [-x(t)*y(t)**3 + Derivative(x(t), t), \
+ -y(t)**5 + Derivative(y(t), t)], 'order': {y(t): 1, x(t): 1}}
+ assert classify_sysode(eq11) == sol11
+
+ eq13 = (Eq(x1,x(t)*y(t)*sin(t)**2), Eq(y1,y(t)**2*sin(t)**2))
+ sol13 = {'no_of_equation': 2, 'func_coeff': {(0, x(t), 0): -y(t)*sin(t)**2, (1, x(t), 1): 0, (0, x(t), 1): 1, \
+ (1, y(t), 0): 0, (1, x(t), 0): 0, (0, y(t), 1): 0, (0, y(t), 0): -x(t)*sin(t)**2, (1, y(t), 1): 1}, \
+ 'type_of_equation': 'type4', 'func': [x(t), y(t)], 'is_linear': False, 'eq': [-x(t)*y(t)*sin(t)**2 + \
+ Derivative(x(t), t), -y(t)**2*sin(t)**2 + Derivative(y(t), t)], 'order': {y(t): 1, x(t): 1}}
+ assert classify_sysode(eq13) == sol13
+
+
+def test_solve_ics():
+ # Basic tests that things work from dsolve.
+ assert dsolve(f(x).diff(x) - 1/f(x), f(x), ics={f(1): 2}) == \
+ Eq(f(x), sqrt(2 * x + 2))
+ assert dsolve(f(x).diff(x) - f(x), f(x), ics={f(0): 1}) == Eq(f(x), exp(x))
+ assert dsolve(f(x).diff(x) - f(x), f(x), ics={f(x).diff(x).subs(x, 0): 1}) == Eq(f(x), exp(x))
+ assert dsolve(f(x).diff(x, x) + f(x), f(x), ics={f(0): 1,
+ f(x).diff(x).subs(x, 0): 1}) == Eq(f(x), sin(x) + cos(x))
+ assert dsolve([f(x).diff(x) - f(x) + g(x), g(x).diff(x) - g(x) - f(x)],
+ [f(x), g(x)], ics={f(0): 1, g(0): 0}) == [Eq(f(x), exp(x)*cos(x)), Eq(g(x), exp(x)*sin(x))]
+
+ # Test cases where dsolve returns two solutions.
+ eq = (x**2*f(x)**2 - x).diff(x)
+ assert dsolve(eq, f(x), ics={f(1): 0}) == [Eq(f(x),
+ -sqrt(x - 1)/x), Eq(f(x), sqrt(x - 1)/x)]
+ assert dsolve(eq, f(x), ics={f(x).diff(x).subs(x, 1): 0}) == [Eq(f(x),
+ -sqrt(x - S.Half)/x), Eq(f(x), sqrt(x - S.Half)/x)]
+
+ eq = cos(f(x)) - (x*sin(f(x)) - f(x)**2)*f(x).diff(x)
+ assert dsolve(eq, f(x),
+ ics={f(0):1}, hint='1st_exact', simplify=False) == Eq(x*cos(f(x)) + f(x)**3/3, Rational(1, 3))
+ assert dsolve(eq, f(x),
+ ics={f(0):1}, hint='1st_exact', simplify=True) == Eq(x*cos(f(x)) + f(x)**3/3, Rational(1, 3))
+
+ assert solve_ics([Eq(f(x), C1*exp(x))], [f(x)], [C1], {f(0): 1}) == {C1: 1}
+ assert solve_ics([Eq(f(x), C1*sin(x) + C2*cos(x))], [f(x)], [C1, C2],
+ {f(0): 1, f(pi/2): 1}) == {C1: 1, C2: 1}
+
+ assert solve_ics([Eq(f(x), C1*sin(x) + C2*cos(x))], [f(x)], [C1, C2],
+ {f(0): 1, f(x).diff(x).subs(x, 0): 1}) == {C1: 1, C2: 1}
+
+ assert solve_ics([Eq(f(x), C1*sin(x) + C2*cos(x))], [f(x)], [C1, C2], {f(0): 1}) == \
+ {C2: 1}
+
+ # Some more complicated tests Refer to PR #16098
+
+ assert set(dsolve(f(x).diff(x)*(f(x).diff(x, 2)-x), ics={f(0):0, f(x).diff(x).subs(x, 1):0})) == \
+ {Eq(f(x), 0), Eq(f(x), x ** 3 / 6 - x / 2)}
+ assert set(dsolve(f(x).diff(x)*(f(x).diff(x, 2)-x), ics={f(0):0})) == \
+ {Eq(f(x), 0), Eq(f(x), C2*x + x**3/6)}
+
+ K, r, f0 = symbols('K r f0')
+ sol = Eq(f(x), K*f0*exp(r*x)/((-K + f0)*(f0*exp(r*x)/(-K + f0) - 1)))
+ assert (dsolve(Eq(f(x).diff(x), r * f(x) * (1 - f(x) / K)), f(x), ics={f(0): f0})) == sol
+
+
+ #Order dependent issues Refer to PR #16098
+ assert set(dsolve(f(x).diff(x)*(f(x).diff(x, 2)-x), ics={f(x).diff(x).subs(x,0):0, f(0):0})) == \
+ {Eq(f(x), 0), Eq(f(x), x ** 3 / 6)}
+ assert set(dsolve(f(x).diff(x)*(f(x).diff(x, 2)-x), ics={f(0):0, f(x).diff(x).subs(x,0):0})) == \
+ {Eq(f(x), 0), Eq(f(x), x ** 3 / 6)}
+
+ # XXX: Ought to be ValueError
+ raises(ValueError, lambda: solve_ics([Eq(f(x), C1*sin(x) + C2*cos(x))], [f(x)], [C1, C2], {f(0): 1, f(pi): 1}))
+
+ # Degenerate case. f'(0) is identically 0.
+ raises(ValueError, lambda: solve_ics([Eq(f(x), sqrt(C1 - x**2))], [f(x)], [C1], {f(x).diff(x).subs(x, 0): 0}))
+
+ EI, q, L = symbols('EI q L')
+
+ # eq = Eq(EI*diff(f(x), x, 4), q)
+ sols = [Eq(f(x), C1 + C2*x + C3*x**2 + C4*x**3 + q*x**4/(24*EI))]
+ funcs = [f(x)]
+ constants = [C1, C2, C3, C4]
+ # Test both cases, Derivative (the default from f(x).diff(x).subs(x, L)),
+ # and Subs
+ ics1 = {f(0): 0,
+ f(x).diff(x).subs(x, 0): 0,
+ f(L).diff(L, 2): 0,
+ f(L).diff(L, 3): 0}
+ ics2 = {f(0): 0,
+ f(x).diff(x).subs(x, 0): 0,
+ Subs(f(x).diff(x, 2), x, L): 0,
+ Subs(f(x).diff(x, 3), x, L): 0}
+
+ solved_constants1 = solve_ics(sols, funcs, constants, ics1)
+ solved_constants2 = solve_ics(sols, funcs, constants, ics2)
+ assert solved_constants1 == solved_constants2 == {
+ C1: 0,
+ C2: 0,
+ C3: L**2*q/(4*EI),
+ C4: -L*q/(6*EI)}
+
+ # Allow the ics to refer to f
+ ics = {f(0): f(0)}
+ assert dsolve(f(x).diff(x) - f(x), f(x), ics=ics) == Eq(f(x), f(0)*exp(x))
+
+ ics = {f(x).diff(x).subs(x, 0): f(x).diff(x).subs(x, 0), f(0): f(0)}
+ assert dsolve(f(x).diff(x, x) + f(x), f(x), ics=ics) == \
+ Eq(f(x), f(0)*cos(x) + f(x).diff(x).subs(x, 0)*sin(x))
+
+def test_ode_order():
+ f = Function('f')
+ g = Function('g')
+ x = Symbol('x')
+ assert ode_order(3*x*exp(f(x)), f(x)) == 0
+ assert ode_order(x*diff(f(x), x) + 3*x*f(x) - sin(x)/x, f(x)) == 1
+ assert ode_order(x**2*f(x).diff(x, x) + x*diff(f(x), x) - f(x), f(x)) == 2
+ assert ode_order(diff(x*exp(f(x)), x, x), f(x)) == 2
+ assert ode_order(diff(x*diff(x*exp(f(x)), x, x), x), f(x)) == 3
+ assert ode_order(diff(f(x), x, x), g(x)) == 0
+ assert ode_order(diff(f(x), x, x)*diff(g(x), x), f(x)) == 2
+ assert ode_order(diff(f(x), x, x)*diff(g(x), x), g(x)) == 1
+ assert ode_order(diff(x*diff(x*exp(f(x)), x, x), x), g(x)) == 0
+ # issue 5835: ode_order has to also work for unevaluated derivatives
+ # (ie, without using doit()).
+ assert ode_order(Derivative(x*f(x), x), f(x)) == 1
+ assert ode_order(x*sin(Derivative(x*f(x)**2, x, x)), f(x)) == 2
+ assert ode_order(Derivative(x*Derivative(x*exp(f(x)), x, x), x), g(x)) == 0
+ assert ode_order(Derivative(f(x), x, x), g(x)) == 0
+ assert ode_order(Derivative(x*exp(f(x)), x, x), f(x)) == 2
+ assert ode_order(Derivative(f(x), x, x)*Derivative(g(x), x), g(x)) == 1
+ assert ode_order(Derivative(x*Derivative(f(x), x, x), x), f(x)) == 3
+ assert ode_order(
+ x*sin(Derivative(x*Derivative(f(x), x)**2, x, x)), f(x)) == 3
+
+
+def test_homogeneous_order():
+ assert homogeneous_order(exp(y/x) + tan(y/x), x, y) == 0
+ assert homogeneous_order(x**2 + sin(x)*cos(y), x, y) is None
+ assert homogeneous_order(x - y - x*sin(y/x), x, y) == 1
+ assert homogeneous_order((x*y + sqrt(x**4 + y**4) + x**2*(log(x) - log(y)))/
+ (pi*x**Rational(2, 3)*sqrt(y)**3), x, y) == Rational(-1, 6)
+ assert homogeneous_order(y/x*cos(y/x) - x/y*sin(y/x) + cos(y/x), x, y) == 0
+ assert homogeneous_order(f(x), x, f(x)) == 1
+ assert homogeneous_order(f(x)**2, x, f(x)) == 2
+ assert homogeneous_order(x*y*z, x, y) == 2
+ assert homogeneous_order(x*y*z, x, y, z) == 3
+ assert homogeneous_order(x**2*f(x)/sqrt(x**2 + f(x)**2), f(x)) is None
+ assert homogeneous_order(f(x, y)**2, x, f(x, y), y) == 2
+ assert homogeneous_order(f(x, y)**2, x, f(x), y) is None
+ assert homogeneous_order(f(x, y)**2, x, f(x, y)) is None
+ assert homogeneous_order(f(y, x)**2, x, y, f(x, y)) is None
+ assert homogeneous_order(f(y), f(x), x) is None
+ assert homogeneous_order(-f(x)/x + 1/sin(f(x)/ x), f(x), x) == 0
+ assert homogeneous_order(log(1/y) + log(x**2), x, y) is None
+ assert homogeneous_order(log(1/y) + log(x), x, y) == 0
+ assert homogeneous_order(log(x/y), x, y) == 0
+ assert homogeneous_order(2*log(1/y) + 2*log(x), x, y) == 0
+ a = Symbol('a')
+ assert homogeneous_order(a*log(1/y) + a*log(x), x, y) == 0
+ assert homogeneous_order(f(x).diff(x), x, y) is None
+ assert homogeneous_order(-f(x).diff(x) + x, x, y) is None
+ assert homogeneous_order(O(x), x, y) is None
+ assert homogeneous_order(x + O(x**2), x, y) is None
+ assert homogeneous_order(x**pi, x) == pi
+ assert homogeneous_order(x**x, x) is None
+ raises(ValueError, lambda: homogeneous_order(x*y))
+
+
+@XFAIL
+def test_noncircularized_real_imaginary_parts():
+ # If this passes, lines numbered 3878-3882 (at the time of this commit)
+ # of sympy/solvers/ode.py for nth_linear_constant_coeff_homogeneous
+ # should be removed.
+ y = sqrt(1+x)
+ i, r = im(y), re(y)
+ assert not (i.has(atan2) and r.has(atan2))
+
+
+def test_collect_respecting_exponentials():
+ # If this test passes, lines 1306-1311 (at the time of this commit)
+ # of sympy/solvers/ode.py should be removed.
+ sol = 1 + exp(x/2)
+ assert sol == collect( sol, exp(x/3))
+
+
+def test_undetermined_coefficients_match():
+ assert _undetermined_coefficients_match(g(x), x) == {'test': False}
+ assert _undetermined_coefficients_match(sin(2*x + sqrt(5)), x) == \
+ {'test': True, 'trialset':
+ {cos(2*x + sqrt(5)), sin(2*x + sqrt(5))}}
+ assert _undetermined_coefficients_match(sin(x)*cos(x), x) == \
+ {'test': False}
+ s = {cos(x), x*cos(x), x**2*cos(x), x**2*sin(x), x*sin(x), sin(x)}
+ assert _undetermined_coefficients_match(sin(x)*(x**2 + x + 1), x) == \
+ {'test': True, 'trialset': s}
+ assert _undetermined_coefficients_match(
+ sin(x)*x**2 + sin(x)*x + sin(x), x) == {'test': True, 'trialset': s}
+ assert _undetermined_coefficients_match(
+ exp(2*x)*sin(x)*(x**2 + x + 1), x
+ ) == {
+ 'test': True, 'trialset': {exp(2*x)*sin(x), x**2*exp(2*x)*sin(x),
+ cos(x)*exp(2*x), x**2*cos(x)*exp(2*x), x*cos(x)*exp(2*x),
+ x*exp(2*x)*sin(x)}}
+ assert _undetermined_coefficients_match(1/sin(x), x) == {'test': False}
+ assert _undetermined_coefficients_match(log(x), x) == {'test': False}
+ assert _undetermined_coefficients_match(2**(x)*(x**2 + x + 1), x) == \
+ {'test': True, 'trialset': {2**x, x*2**x, x**2*2**x}}
+ assert _undetermined_coefficients_match(x**y, x) == {'test': False}
+ assert _undetermined_coefficients_match(exp(x)*exp(2*x + 1), x) == \
+ {'test': True, 'trialset': {exp(1 + 3*x)}}
+ assert _undetermined_coefficients_match(sin(x)*(x**2 + x + 1), x) == \
+ {'test': True, 'trialset': {x*cos(x), x*sin(x), x**2*cos(x),
+ x**2*sin(x), cos(x), sin(x)}}
+ assert _undetermined_coefficients_match(sin(x)*(x + sin(x)), x) == \
+ {'test': False}
+ assert _undetermined_coefficients_match(sin(x)*(x + sin(2*x)), x) == \
+ {'test': False}
+ assert _undetermined_coefficients_match(sin(x)*tan(x), x) == \
+ {'test': False}
+ assert _undetermined_coefficients_match(
+ x**2*sin(x)*exp(x) + x*sin(x) + x, x
+ ) == {
+ 'test': True, 'trialset': {x**2*cos(x)*exp(x), x, cos(x), S.One,
+ exp(x)*sin(x), sin(x), x*exp(x)*sin(x), x*cos(x), x*cos(x)*exp(x),
+ x*sin(x), cos(x)*exp(x), x**2*exp(x)*sin(x)}}
+ assert _undetermined_coefficients_match(4*x*sin(x - 2), x) == {
+ 'trialset': {x*cos(x - 2), x*sin(x - 2), cos(x - 2), sin(x - 2)},
+ 'test': True,
+ }
+ assert _undetermined_coefficients_match(2**x*x, x) == \
+ {'test': True, 'trialset': {2**x, x*2**x}}
+ assert _undetermined_coefficients_match(2**x*exp(2*x), x) == \
+ {'test': True, 'trialset': {2**x*exp(2*x)}}
+ assert _undetermined_coefficients_match(exp(-x)/x, x) == \
+ {'test': False}
+ # Below are from Ordinary Differential Equations,
+ # Tenenbaum and Pollard, pg. 231
+ assert _undetermined_coefficients_match(S(4), x) == \
+ {'test': True, 'trialset': {S.One}}
+ assert _undetermined_coefficients_match(12*exp(x), x) == \
+ {'test': True, 'trialset': {exp(x)}}
+ assert _undetermined_coefficients_match(exp(I*x), x) == \
+ {'test': True, 'trialset': {exp(I*x)}}
+ assert _undetermined_coefficients_match(sin(x), x) == \
+ {'test': True, 'trialset': {cos(x), sin(x)}}
+ assert _undetermined_coefficients_match(cos(x), x) == \
+ {'test': True, 'trialset': {cos(x), sin(x)}}
+ assert _undetermined_coefficients_match(8 + 6*exp(x) + 2*sin(x), x) == \
+ {'test': True, 'trialset': {S.One, cos(x), sin(x), exp(x)}}
+ assert _undetermined_coefficients_match(x**2, x) == \
+ {'test': True, 'trialset': {S.One, x, x**2}}
+ assert _undetermined_coefficients_match(9*x*exp(x) + exp(-x), x) == \
+ {'test': True, 'trialset': {x*exp(x), exp(x), exp(-x)}}
+ assert _undetermined_coefficients_match(2*exp(2*x)*sin(x), x) == \
+ {'test': True, 'trialset': {exp(2*x)*sin(x), cos(x)*exp(2*x)}}
+ assert _undetermined_coefficients_match(x - sin(x), x) == \
+ {'test': True, 'trialset': {S.One, x, cos(x), sin(x)}}
+ assert _undetermined_coefficients_match(x**2 + 2*x, x) == \
+ {'test': True, 'trialset': {S.One, x, x**2}}
+ assert _undetermined_coefficients_match(4*x*sin(x), x) == \
+ {'test': True, 'trialset': {x*cos(x), x*sin(x), cos(x), sin(x)}}
+ assert _undetermined_coefficients_match(x*sin(2*x), x) == \
+ {'test': True, 'trialset':
+ {x*cos(2*x), x*sin(2*x), cos(2*x), sin(2*x)}}
+ assert _undetermined_coefficients_match(x**2*exp(-x), x) == \
+ {'test': True, 'trialset': {x*exp(-x), x**2*exp(-x), exp(-x)}}
+ assert _undetermined_coefficients_match(2*exp(-x) - x**2*exp(-x), x) == \
+ {'test': True, 'trialset': {x*exp(-x), x**2*exp(-x), exp(-x)}}
+ assert _undetermined_coefficients_match(exp(-2*x) + x**2, x) == \
+ {'test': True, 'trialset': {S.One, x, x**2, exp(-2*x)}}
+ assert _undetermined_coefficients_match(x*exp(-x), x) == \
+ {'test': True, 'trialset': {x*exp(-x), exp(-x)}}
+ assert _undetermined_coefficients_match(x + exp(2*x), x) == \
+ {'test': True, 'trialset': {S.One, x, exp(2*x)}}
+ assert _undetermined_coefficients_match(sin(x) + exp(-x), x) == \
+ {'test': True, 'trialset': {cos(x), sin(x), exp(-x)}}
+ assert _undetermined_coefficients_match(exp(x), x) == \
+ {'test': True, 'trialset': {exp(x)}}
+ # converted from sin(x)**2
+ assert _undetermined_coefficients_match(S.Half - cos(2*x)/2, x) == \
+ {'test': True, 'trialset': {S.One, cos(2*x), sin(2*x)}}
+ # converted from exp(2*x)*sin(x)**2
+ assert _undetermined_coefficients_match(
+ exp(2*x)*(S.Half + cos(2*x)/2), x
+ ) == {
+ 'test': True, 'trialset': {exp(2*x)*sin(2*x), cos(2*x)*exp(2*x),
+ exp(2*x)}}
+ assert _undetermined_coefficients_match(2*x + sin(x) + cos(x), x) == \
+ {'test': True, 'trialset': {S.One, x, cos(x), sin(x)}}
+ # converted from sin(2*x)*sin(x)
+ assert _undetermined_coefficients_match(cos(x)/2 - cos(3*x)/2, x) == \
+ {'test': True, 'trialset': {cos(x), cos(3*x), sin(x), sin(3*x)}}
+ assert _undetermined_coefficients_match(cos(x**2), x) == {'test': False}
+ assert _undetermined_coefficients_match(2**(x**2), x) == {'test': False}
+
+
+def test_issue_4785_22462():
+ from sympy.abc import A
+ eq = x + A*(x + diff(f(x), x) + f(x)) + diff(f(x), x) + f(x) + 2
+ assert classify_ode(eq, f(x)) == ('factorable', '1st_exact', '1st_linear',
+ 'Bernoulli', 'almost_linear', '1st_power_series', 'lie_group',
+ 'nth_linear_constant_coeff_undetermined_coefficients',
+ 'nth_linear_constant_coeff_variation_of_parameters',
+ '1st_exact_Integral', '1st_linear_Integral', 'Bernoulli_Integral',
+ 'almost_linear_Integral',
+ 'nth_linear_constant_coeff_variation_of_parameters_Integral')
+ # issue 4864
+ eq = (x**2 + f(x)**2)*f(x).diff(x) - 2*x*f(x)
+ assert classify_ode(eq, f(x)) == ('factorable', '1st_exact',
+ '1st_homogeneous_coeff_best',
+ '1st_homogeneous_coeff_subs_indep_div_dep',
+ '1st_homogeneous_coeff_subs_dep_div_indep',
+ '1st_power_series',
+ 'lie_group', '1st_exact_Integral',
+ '1st_homogeneous_coeff_subs_indep_div_dep_Integral',
+ '1st_homogeneous_coeff_subs_dep_div_indep_Integral')
+
+
+def test_issue_4825():
+ raises(ValueError, lambda: dsolve(f(x, y).diff(x) - y*f(x, y), f(x)))
+ assert classify_ode(f(x, y).diff(x) - y*f(x, y), f(x), dict=True) == \
+ {'order': 0, 'default': None, 'ordered_hints': ()}
+ # See also issue 3793, test Z13.
+ raises(ValueError, lambda: dsolve(f(x).diff(x), f(y)))
+ assert classify_ode(f(x).diff(x), f(y), dict=True) == \
+ {'order': 0, 'default': None, 'ordered_hints': ()}
+
+
+def test_constant_renumber_order_issue_5308():
+ from sympy.utilities.iterables import variations
+
+ assert constant_renumber(C1*x + C2*y) == \
+ constant_renumber(C1*y + C2*x) == \
+ C1*x + C2*y
+ e = C1*(C2 + x)*(C3 + y)
+ for a, b, c in variations([C1, C2, C3], 3):
+ assert constant_renumber(a*(b + x)*(c + y)) == e
+
+
+def test_constant_renumber():
+ e1, e2, x, y = symbols("e1:3 x y")
+ exprs = [e2*x, e1*x + e2*y]
+
+ assert constant_renumber(exprs[0]) == e2*x
+ assert constant_renumber(exprs[0], variables=[x]) == C1*x
+ assert constant_renumber(exprs[0], variables=[x], newconstants=[C2]) == C2*x
+ assert constant_renumber(exprs, variables=[x, y]) == [C1*x, C1*y + C2*x]
+ assert constant_renumber(exprs, variables=[x, y], newconstants=symbols("C3:5")) == [C3*x, C3*y + C4*x]
+
+
+def test_issue_5770():
+ k = Symbol("k", real=True)
+ t = Symbol('t')
+ w = Function('w')
+ sol = dsolve(w(t).diff(t, 6) - k**6*w(t), w(t))
+ assert len([s for s in sol.free_symbols if s.name.startswith('C')]) == 6
+ assert constantsimp((C1*cos(x) + C2*cos(x))*exp(x), {C1, C2}) == \
+ C1*cos(x)*exp(x)
+ assert constantsimp(C1*cos(x) + C2*cos(x) + C3*sin(x), {C1, C2, C3}) == \
+ C1*cos(x) + C3*sin(x)
+ assert constantsimp(exp(C1 + x), {C1}) == C1*exp(x)
+ assert constantsimp(x + C1 + y, {C1, y}) == C1 + x
+ assert constantsimp(x + C1 + Integral(x, (x, 1, 2)), {C1}) == C1 + x
+
+
+def test_issue_5112_5430():
+ assert homogeneous_order(-log(x) + acosh(x), x) is None
+ assert homogeneous_order(y - log(x), x, y) is None
+
+
+def test_issue_5095():
+ f = Function('f')
+ raises(ValueError, lambda: dsolve(f(x).diff(x)**2, f(x), 'fdsjf'))
+
+
+def test_homogeneous_function():
+ f = Function('f')
+ eq1 = tan(x + f(x))
+ eq2 = sin((3*x)/(4*f(x)))
+ eq3 = cos(x*f(x)*Rational(3, 4))
+ eq4 = log((3*x + 4*f(x))/(5*f(x) + 7*x))
+ eq5 = exp((2*x**2)/(3*f(x)**2))
+ eq6 = log((3*x + 4*f(x))/(5*f(x) + 7*x) + exp((2*x**2)/(3*f(x)**2)))
+ eq7 = sin((3*x)/(5*f(x) + x**2))
+ assert homogeneous_order(eq1, x, f(x)) == None
+ assert homogeneous_order(eq2, x, f(x)) == 0
+ assert homogeneous_order(eq3, x, f(x)) == None
+ assert homogeneous_order(eq4, x, f(x)) == 0
+ assert homogeneous_order(eq5, x, f(x)) == 0
+ assert homogeneous_order(eq6, x, f(x)) == 0
+ assert homogeneous_order(eq7, x, f(x)) == None
+
+
+def test_linear_coeff_match():
+ n, d = z*(2*x + 3*f(x) + 5), z*(7*x + 9*f(x) + 11)
+ rat = n/d
+ eq1 = sin(rat) + cos(rat.expand())
+ obj1 = LinearCoefficients(eq1)
+ eq2 = rat
+ obj2 = LinearCoefficients(eq2)
+ eq3 = log(sin(rat))
+ obj3 = LinearCoefficients(eq3)
+ ans = (4, Rational(-13, 3))
+ assert obj1._linear_coeff_match(eq1, f(x)) == ans
+ assert obj2._linear_coeff_match(eq2, f(x)) == ans
+ assert obj3._linear_coeff_match(eq3, f(x)) == ans
+
+ # no c
+ eq4 = (3*x)/f(x)
+ obj4 = LinearCoefficients(eq4)
+ # not x and f(x)
+ eq5 = (3*x + 2)/x
+ obj5 = LinearCoefficients(eq5)
+ # denom will be zero
+ eq6 = (3*x + 2*f(x) + 1)/(3*x + 2*f(x) + 5)
+ obj6 = LinearCoefficients(eq6)
+ # not rational coefficient
+ eq7 = (3*x + 2*f(x) + sqrt(2))/(3*x + 2*f(x) + 5)
+ obj7 = LinearCoefficients(eq7)
+ assert obj4._linear_coeff_match(eq4, f(x)) is None
+ assert obj5._linear_coeff_match(eq5, f(x)) is None
+ assert obj6._linear_coeff_match(eq6, f(x)) is None
+ assert obj7._linear_coeff_match(eq7, f(x)) is None
+
+
+def test_constantsimp_take_problem():
+ c = exp(C1) + 2
+ assert len(Poly(constantsimp(exp(C1) + c + c*x, [C1])).gens) == 2
+
+
+def test_series():
+ C1 = Symbol("C1")
+ eq = f(x).diff(x) - f(x)
+ sol = Eq(f(x), C1 + C1*x + C1*x**2/2 + C1*x**3/6 + C1*x**4/24 +
+ C1*x**5/120 + O(x**6))
+ assert dsolve(eq, hint='1st_power_series') == sol
+ assert checkodesol(eq, sol, order=1)[0]
+
+ eq = f(x).diff(x) - x*f(x)
+ sol = Eq(f(x), C1*x**4/8 + C1*x**2/2 + C1 + O(x**6))
+ assert dsolve(eq, hint='1st_power_series') == sol
+ assert checkodesol(eq, sol, order=1)[0]
+
+ eq = f(x).diff(x) - sin(x*f(x))
+ sol = Eq(f(x), (x - 2)**2*(1+ sin(4))*cos(4) + (x - 2)*sin(4) + 2 + O(x**3))
+ assert dsolve(eq, hint='1st_power_series', ics={f(2): 2}, n=3) == sol
+ # FIXME: The solution here should be O((x-2)**3) so is incorrect
+ #assert checkodesol(eq, sol, order=1)[0]
+
+
+@slow
+def test_2nd_power_series_ordinary():
+ C1, C2 = symbols("C1 C2")
+
+ eq = f(x).diff(x, 2) - x*f(x)
+ assert classify_ode(eq) == ('2nd_linear_airy', '2nd_power_series_ordinary')
+ sol = Eq(f(x), C2*(x**3/6 + 1) + C1*x*(x**3/12 + 1) + O(x**6))
+ assert dsolve(eq, hint='2nd_power_series_ordinary') == sol
+ assert checkodesol(eq, sol) == (True, 0)
+
+ sol = Eq(f(x), C2*((x + 2)**4/6 + (x + 2)**3/6 - (x + 2)**2 + 1)
+ + C1*(x + (x + 2)**4/12 - (x + 2)**3/3 + S(2))
+ + O(x**6))
+ assert dsolve(eq, hint='2nd_power_series_ordinary', x0=-2) == sol
+ # FIXME: Solution should be O((x+2)**6)
+ # assert checkodesol(eq, sol) == (True, 0)
+
+ sol = Eq(f(x), C2*x + C1 + O(x**2))
+ assert dsolve(eq, hint='2nd_power_series_ordinary', n=2) == sol
+ assert checkodesol(eq, sol) == (True, 0)
+
+ eq = (1 + x**2)*(f(x).diff(x, 2)) + 2*x*(f(x).diff(x)) -2*f(x)
+ assert classify_ode(eq) == ('factorable', '2nd_hypergeometric', '2nd_hypergeometric_Integral',
+ '2nd_power_series_ordinary')
+
+ sol = Eq(f(x), C2*(-x**4/3 + x**2 + 1) + C1*x + O(x**6))
+ assert dsolve(eq, hint='2nd_power_series_ordinary') == sol
+ assert checkodesol(eq, sol) == (True, 0)
+
+ eq = f(x).diff(x, 2) + x*(f(x).diff(x)) + f(x)
+ assert classify_ode(eq) == ('factorable', '2nd_power_series_ordinary',)
+ sol = Eq(f(x), C2*(x**4/8 - x**2/2 + 1) + C1*x*(-x**2/3 + 1) + O(x**6))
+ assert dsolve(eq) == sol
+ # FIXME: checkodesol fails for this solution...
+ # assert checkodesol(eq, sol) == (True, 0)
+
+ eq = f(x).diff(x, 2) + f(x).diff(x) - x*f(x)
+ assert classify_ode(eq) == ('2nd_power_series_ordinary',)
+ sol = Eq(f(x), C2*(-x**4/24 + x**3/6 + 1)
+ + C1*x*(x**3/24 + x**2/6 - x/2 + 1) + O(x**6))
+ assert dsolve(eq) == sol
+ # FIXME: checkodesol fails for this solution...
+ # assert checkodesol(eq, sol) == (True, 0)
+
+ eq = f(x).diff(x, 2) + x*f(x)
+ assert classify_ode(eq) == ('2nd_linear_airy', '2nd_power_series_ordinary')
+ sol = Eq(f(x), C2*(x**6/180 - x**3/6 + 1) + C1*x*(-x**3/12 + 1) + O(x**7))
+ assert dsolve(eq, hint='2nd_power_series_ordinary', n=7) == sol
+ assert checkodesol(eq, sol) == (True, 0)
+
+
+def test_2nd_power_series_regular():
+ C1, C2, a = symbols("C1 C2 a")
+ eq = x**2*(f(x).diff(x, 2)) - 3*x*(f(x).diff(x)) + (4*x + 4)*f(x)
+ sol = Eq(f(x), C1*x**2*(-16*x**3/9 + 4*x**2 - 4*x + 1) + O(x**6))
+ assert dsolve(eq, hint='2nd_power_series_regular') == sol
+ assert checkodesol(eq, sol) == (True, 0)
+
+ eq = 4*x**2*(f(x).diff(x, 2)) -8*x**2*(f(x).diff(x)) + (4*x**2 +
+ 1)*f(x)
+ sol = Eq(f(x), C1*sqrt(x)*(x**4/24 + x**3/6 + x**2/2 + x + 1) + O(x**6))
+ assert dsolve(eq, hint='2nd_power_series_regular') == sol
+ assert checkodesol(eq, sol) == (True, 0)
+
+ eq = x**2*(f(x).diff(x, 2)) - x**2*(f(x).diff(x)) + (
+ x**2 - 2)*f(x)
+ sol = Eq(f(x), C1*(-x**6/720 - 3*x**5/80 - x**4/8 + x**2/2 + x/2 + 1)/x +
+ C2*x**2*(-x**3/60 + x**2/20 + x/2 + 1) + O(x**6))
+ assert dsolve(eq) == sol
+ assert checkodesol(eq, sol) == (True, 0)
+
+ eq = x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (x**2 - Rational(1, 4))*f(x)
+ sol = Eq(f(x), C1*(x**4/24 - x**2/2 + 1)/sqrt(x) +
+ C2*sqrt(x)*(x**4/120 - x**2/6 + 1) + O(x**6))
+ assert dsolve(eq, hint='2nd_power_series_regular') == sol
+ assert checkodesol(eq, sol) == (True, 0)
+
+ eq = x*f(x).diff(x, 2) + f(x).diff(x) - a*x*f(x)
+ sol = Eq(f(x), C1*(a**2*x**4/64 + a*x**2/4 + 1) + O(x**6))
+ assert dsolve(eq, f(x), hint="2nd_power_series_regular") == sol
+ assert checkodesol(eq, sol) == (True, 0)
+
+ eq = f(x).diff(x, 2) + ((1 - x)/x)*f(x).diff(x) + (a/x)*f(x)
+ sol = Eq(f(x), C1*(-a*x**5*(a - 4)*(a - 3)*(a - 2)*(a - 1)/14400 + \
+ a*x**4*(a - 3)*(a - 2)*(a - 1)/576 - a*x**3*(a - 2)*(a - 1)/36 + \
+ a*x**2*(a - 1)/4 - a*x + 1) + O(x**6))
+ assert dsolve(eq, f(x), hint="2nd_power_series_regular") == sol
+ assert checkodesol(eq, sol) == (True, 0)
+
+
+def test_issue_15056():
+ t = Symbol('t')
+ C3 = Symbol('C3')
+ assert get_numbered_constants(Symbol('C1') * Function('C2')(t)) == C3
+
+
+def test_issue_15913():
+ eq = -C1/x - 2*x*f(x) - f(x) + Derivative(f(x), x)
+ sol = C2*exp(x**2 + x) + exp(x**2 + x)*Integral(C1*exp(-x**2 - x)/x, x)
+ assert checkodesol(eq, sol) == (True, 0)
+ sol = C1 + C2*exp(-x*y)
+ eq = Derivative(y*f(x), x) + f(x).diff(x, 2)
+ assert checkodesol(eq, sol, f(x)) == (True, 0)
+
+
+def test_issue_16146():
+ raises(ValueError, lambda: dsolve([f(x).diff(x), g(x).diff(x)], [f(x), g(x), h(x)]))
+ raises(ValueError, lambda: dsolve([f(x).diff(x), g(x).diff(x)], [f(x)]))
+
+
+def test_dsolve_remove_redundant_solutions():
+
+ eq = (f(x)-2)*f(x).diff(x)
+ sol = Eq(f(x), C1)
+ assert dsolve(eq) == sol
+
+ eq = (f(x)-sin(x))*(f(x).diff(x, 2))
+ sol = {Eq(f(x), C1 + C2*x), Eq(f(x), sin(x))}
+ assert set(dsolve(eq)) == sol
+
+ eq = (f(x)**2-2*f(x)+1)*f(x).diff(x, 3)
+ sol = Eq(f(x), C1 + C2*x + C3*x**2)
+ assert dsolve(eq) == sol
+
+
+def test_issue_13060():
+ A, B = symbols("A B", cls=Function)
+ t = Symbol("t")
+ eq = [Eq(Derivative(A(t), t), A(t)*B(t)), Eq(Derivative(B(t), t), A(t)*B(t))]
+ sol = dsolve(eq)
+ assert checkodesol(eq, sol) == (True, [0, 0])
+
+
+def test_issue_22523():
+ N, s = symbols('N s')
+ rho = Function('rho')
+ # intentionally use 4.0 to confirm issue with nfloat
+ # works here
+ eqn = 4.0*N*sqrt(N - 1)*rho(s) + (4*s**2*(N - 1) + (N - 2*s*(N - 1))**2
+ )*Derivative(rho(s), (s, 2))
+ match = classify_ode(eqn, dict=True, hint='all')
+ assert match['2nd_power_series_ordinary']['terms'] == 5
+ C1, C2 = symbols('C1,C2')
+ sol = dsolve(eqn, hint='2nd_power_series_ordinary')
+ # there is no r(2.0) in this result
+ assert filldedent(sol) == filldedent(str('''
+ Eq(rho(s), C2*(1 - 4.0*s**4*sqrt(N - 1.0)/N + 0.666666666666667*s**4/N
+ - 2.66666666666667*s**3*sqrt(N - 1.0)/N - 2.0*s**2*sqrt(N - 1.0)/N +
+ 9.33333333333333*s**4*sqrt(N - 1.0)/N**2 - 0.666666666666667*s**4/N**2
+ + 2.66666666666667*s**3*sqrt(N - 1.0)/N**2 -
+ 5.33333333333333*s**4*sqrt(N - 1.0)/N**3) + C1*s*(1.0 -
+ 1.33333333333333*s**3*sqrt(N - 1.0)/N - 0.666666666666667*s**2*sqrt(N
+ - 1.0)/N + 1.33333333333333*s**3*sqrt(N - 1.0)/N**2) + O(s**6))'''))
+
+
+def test_issue_22604():
+ x1, x2 = symbols('x1, x2', cls = Function)
+ t, k1, k2, m1, m2 = symbols('t k1 k2 m1 m2', real = True)
+ k1, k2, m1, m2 = 1, 1, 1, 1
+ eq1 = Eq(m1*diff(x1(t), t, 2) + k1*x1(t) - k2*(x2(t) - x1(t)), 0)
+ eq2 = Eq(m2*diff(x2(t), t, 2) + k2*(x2(t) - x1(t)), 0)
+ eqs = [eq1, eq2]
+ [x1sol, x2sol] = dsolve(eqs, [x1(t), x2(t)], ics = {x1(0):0, x1(t).diff().subs(t,0):0, \
+ x2(0):1, x2(t).diff().subs(t,0):0})
+ assert x1sol == Eq(x1(t), sqrt(3 - sqrt(5))*(sqrt(10) + 5*sqrt(2))*cos(sqrt(2)*t*sqrt(3 - sqrt(5))/2)/20 + \
+ (-5*sqrt(2) + sqrt(10))*sqrt(sqrt(5) + 3)*cos(sqrt(2)*t*sqrt(sqrt(5) + 3)/2)/20)
+ assert x2sol == Eq(x2(t), (sqrt(5) + 5)*cos(sqrt(2)*t*sqrt(3 - sqrt(5))/2)/10 + (5 - sqrt(5))*cos(sqrt(2)*t*sqrt(sqrt(5) + 3)/2)/10)
+
+
+def test_issue_22462():
+ for de in [
+ Eq(f(x).diff(x), -20*f(x)**2 - 500*f(x)/7200),
+ Eq(f(x).diff(x), -2*f(x)**2 - 5*f(x)/7)]:
+ assert 'Bernoulli' in classify_ode(de, f(x))
+
+
+def test_issue_23425():
+ x = symbols('x')
+ y = Function('y')
+ eq = Eq(-E**x*y(x).diff().diff() + y(x).diff(), 0)
+ assert classify_ode(eq) == \
+ ('Liouville', 'nth_order_reducible', \
+ '2nd_power_series_ordinary', 'Liouville_Integral')
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_riccati.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_riccati.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d8e06bf083a7fc214daad43aaee94274afc7003
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_riccati.py
@@ -0,0 +1,877 @@
+from sympy.core.random import randint
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, oo)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import tanh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.polys.polytools import Poly
+from sympy.simplify.ratsimp import ratsimp
+from sympy.solvers.ode.subscheck import checkodesol
+from sympy.testing.pytest import slow
+from sympy.solvers.ode.riccati import (riccati_normal, riccati_inverse_normal,
+ riccati_reduced, match_riccati, inverse_transform_poly, limit_at_inf,
+ check_necessary_conds, val_at_inf, construct_c_case_1,
+ construct_c_case_2, construct_c_case_3, construct_d_case_4,
+ construct_d_case_5, construct_d_case_6, rational_laurent_series,
+ solve_riccati)
+
+f = Function('f')
+x = symbols('x')
+
+# These are the functions used to generate the tests
+# SHOULD NOT BE USED DIRECTLY IN TESTS
+
+def rand_rational(maxint):
+ return Rational(randint(-maxint, maxint), randint(1, maxint))
+
+
+def rand_poly(x, degree, maxint):
+ return Poly([rand_rational(maxint) for _ in range(degree+1)], x)
+
+
+def rand_rational_function(x, degree, maxint):
+ degnum = randint(1, degree)
+ degden = randint(1, degree)
+ num = rand_poly(x, degnum, maxint)
+ den = rand_poly(x, degden, maxint)
+ while den == Poly(0, x):
+ den = rand_poly(x, degden, maxint)
+ return num / den
+
+
+def find_riccati_ode(ratfunc, x, yf):
+ y = ratfunc
+ yp = y.diff(x)
+ q1 = rand_rational_function(x, 1, 3)
+ q2 = rand_rational_function(x, 1, 3)
+ while q2 == 0:
+ q2 = rand_rational_function(x, 1, 3)
+ q0 = ratsimp(yp - q1*y - q2*y**2)
+ eq = Eq(yf.diff(), q0 + q1*yf + q2*yf**2)
+ sol = Eq(yf, y)
+ assert checkodesol(eq, sol) == (True, 0)
+ return eq, q0, q1, q2
+
+
+# Testing functions start
+
+def test_riccati_transformation():
+ """
+ This function tests the transformation of the
+ solution of a Riccati ODE to the solution of
+ its corresponding normal Riccati ODE.
+
+ Each test case 4 values -
+
+ 1. w - The solution to be transformed
+ 2. b1 - The coefficient of f(x) in the ODE.
+ 3. b2 - The coefficient of f(x)**2 in the ODE.
+ 4. y - The solution to the normal Riccati ODE.
+ """
+ tests = [
+ (
+ x/(x - 1),
+ (x**2 + 7)/3*x,
+ x,
+ -x**2/(x - 1) - x*(x**2/3 + S(7)/3)/2 - 1/(2*x)
+ ),
+ (
+ (2*x + 3)/(2*x + 2),
+ (3 - 3*x)/(x + 1),
+ 5*x,
+ -5*x*(2*x + 3)/(2*x + 2) - (3 - 3*x)/(Mul(2, x + 1, evaluate=False)) - 1/(2*x)
+ ),
+ (
+ -1/(2*x**2 - 1),
+ 0,
+ (2 - x)/(4*x - 2),
+ (2 - x)/((4*x - 2)*(2*x**2 - 1)) - (4*x - 2)*(Mul(-4, 2 - x, evaluate=False)/(4*x - \
+ 2)**2 - 1/(4*x - 2))/(Mul(2, 2 - x, evaluate=False))
+ ),
+ (
+ x,
+ (8*x - 12)/(12*x + 9),
+ x**3/(6*x - 9),
+ -x**4/(6*x - 9) - (8*x - 12)/(Mul(2, 12*x + 9, evaluate=False)) - (6*x - 9)*(-6*x**3/(6*x \
+ - 9)**2 + 3*x**2/(6*x - 9))/(2*x**3)
+ )]
+ for w, b1, b2, y in tests:
+ assert y == riccati_normal(w, x, b1, b2)
+ assert w == riccati_inverse_normal(y, x, b1, b2).cancel()
+
+ # Test bp parameter in riccati_inverse_normal
+ tests = [
+ (
+ (-2*x - 1)/(2*x**2 + 2*x - 2),
+ -2/x,
+ (-x - 1)/(4*x),
+ 8*x**2*(1/(4*x) + (-x - 1)/(4*x**2))/(-x - 1)**2 + 4/(-x - 1),
+ -2*x*(-1/(4*x) - (-x - 1)/(4*x**2))/(-x - 1) - (-2*x - 1)*(-x - 1)/(4*x*(2*x**2 + 2*x \
+ - 2)) + 1/x
+ ),
+ (
+ 3/(2*x**2),
+ -2/x,
+ (-x - 1)/(4*x),
+ 8*x**2*(1/(4*x) + (-x - 1)/(4*x**2))/(-x - 1)**2 + 4/(-x - 1),
+ -2*x*(-1/(4*x) - (-x - 1)/(4*x**2))/(-x - 1) + 1/x - Mul(3, -x - 1, evaluate=False)/(8*x**3)
+ )]
+ for w, b1, b2, bp, y in tests:
+ assert y == riccati_normal(w, x, b1, b2)
+ assert w == riccati_inverse_normal(y, x, b1, b2, bp).cancel()
+
+
+def test_riccati_reduced():
+ """
+ This function tests the transformation of a
+ Riccati ODE to its normal Riccati ODE.
+
+ Each test case 2 values -
+
+ 1. eq - A Riccati ODE.
+ 2. normal_eq - The normal Riccati ODE of eq.
+ """
+ tests = [
+ (
+ f(x).diff(x) - x**2 - x*f(x) - x*f(x)**2,
+
+ f(x).diff(x) + f(x)**2 + x**3 - x**2/4 - 3/(4*x**2)
+ ),
+ (
+ 6*x/(2*x + 9) + f(x).diff(x) - (x + 1)*f(x)**2/x,
+
+ -3*x**2*(1/x + (-x - 1)/x**2)**2/(4*(-x - 1)**2) + Mul(6, \
+ -x - 1, evaluate=False)/(2*x + 9) + f(x)**2 + f(x).diff(x) \
+ - (-1 + (x + 1)/x)/(x*(-x - 1))
+ ),
+ (
+ f(x)**2 + f(x).diff(x) - (x - 1)*f(x)/(-x - S(1)/2),
+
+ -(2*x - 2)**2/(4*(2*x + 1)**2) + (2*x - 2)/(2*x + 1)**2 + \
+ f(x)**2 + f(x).diff(x) - 1/(2*x + 1)
+ ),
+ (
+ f(x).diff(x) - f(x)**2/x,
+
+ f(x)**2 + f(x).diff(x) + 1/(4*x**2)
+ ),
+ (
+ -3*(-x**2 - x + 1)/(x**2 + 6*x + 1) + f(x).diff(x) + f(x)**2/x,
+
+ f(x)**2 + f(x).diff(x) + (3*x**2/(x**2 + 6*x + 1) + 3*x/(x**2 \
+ + 6*x + 1) - 3/(x**2 + 6*x + 1))/x + 1/(4*x**2)
+ ),
+ (
+ 6*x/(2*x + 9) + f(x).diff(x) - (x + 1)*f(x)/x,
+
+ False
+ ),
+ (
+ f(x)*f(x).diff(x) - 1/x + f(x)/3 + f(x)**2/(x**2 - 2),
+
+ False
+ )]
+ for eq, normal_eq in tests:
+ assert normal_eq == riccati_reduced(eq, f, x)
+
+
+def test_match_riccati():
+ """
+ This function tests if an ODE is Riccati or not.
+
+ Each test case has 5 values -
+
+ 1. eq - The Riccati ODE.
+ 2. match - Boolean indicating if eq is a Riccati ODE.
+ 3. b0 -
+ 4. b1 - Coefficient of f(x) in eq.
+ 5. b2 - Coefficient of f(x)**2 in eq.
+ """
+ tests = [
+ # Test Rational Riccati ODEs
+ (
+ f(x).diff(x) - (405*x**3 - 882*x**2 - 78*x + 92)/(243*x**4 \
+ - 945*x**3 + 846*x**2 + 180*x - 72) - 2 - f(x)**2/(3*x + 1) \
+ - (S(1)/3 - x)*f(x)/(S(1)/3 - 3*x/2),
+
+ True,
+
+ 45*x**3/(27*x**4 - 105*x**3 + 94*x**2 + 20*x - 8) - 98*x**2/ \
+ (27*x**4 - 105*x**3 + 94*x**2 + 20*x - 8) - 26*x/(81*x**4 - \
+ 315*x**3 + 282*x**2 + 60*x - 24) + 2 + 92/(243*x**4 - 945*x**3 \
+ + 846*x**2 + 180*x - 72),
+
+ Mul(-1, 2 - 6*x, evaluate=False)/(9*x - 2),
+
+ 1/(3*x + 1)
+ ),
+ (
+ f(x).diff(x) + 4*x/27 - (x/3 - 1)*f(x)**2 - (2*x/3 + \
+ 1)*f(x)/(3*x + 2) - S(10)/27 - (265*x**2 + 423*x + 162) \
+ /(324*x**3 + 216*x**2),
+
+ True,
+
+ -4*x/27 + S(10)/27 + 3/(6*x**3 + 4*x**2) + 47/(36*x**2 \
+ + 24*x) + 265/(324*x + 216),
+
+ Mul(-1, -2*x - 3, evaluate=False)/(9*x + 6),
+
+ x/3 - 1
+ ),
+ (
+ f(x).diff(x) - (304*x**5 - 745*x**4 + 631*x**3 - 876*x**2 \
+ + 198*x - 108)/(36*x**6 - 216*x**5 + 477*x**4 - 567*x**3 + \
+ 360*x**2 - 108*x) - S(17)/9 - (x - S(3)/2)*f(x)/(x/2 - \
+ S(3)/2) - (x/3 - 3)*f(x)**2/(3*x),
+
+ True,
+
+ 304*x**4/(36*x**5 - 216*x**4 + 477*x**3 - 567*x**2 + 360*x - \
+ 108) - 745*x**3/(36*x**5 - 216*x**4 + 477*x**3 - 567*x**2 + \
+ 360*x - 108) + 631*x**2/(36*x**5 - 216*x**4 + 477*x**3 - 567* \
+ x**2 + 360*x - 108) - 292*x/(12*x**5 - 72*x**4 + 159*x**3 - \
+ 189*x**2 + 120*x - 36) + S(17)/9 - 12/(4*x**6 - 24*x**5 + \
+ 53*x**4 - 63*x**3 + 40*x**2 - 12*x) + 22/(4*x**5 - 24*x**4 \
+ + 53*x**3 - 63*x**2 + 40*x - 12),
+
+ Mul(-1, 3 - 2*x, evaluate=False)/(x - 3),
+
+ Mul(-1, 9 - x, evaluate=False)/(9*x)
+ ),
+ # Test Non-Rational Riccati ODEs
+ (
+ f(x).diff(x) - x**(S(3)/2)/(x**(S(1)/2) - 2) + x**2*f(x) + \
+ x*f(x)**2/(x**(S(3)/4)),
+ False, 0, 0, 0
+ ),
+ (
+ f(x).diff(x) - sin(x**2) + exp(x)*f(x) + log(x)*f(x)**2,
+ False, 0, 0, 0
+ ),
+ (
+ f(x).diff(x) - tanh(x + sqrt(x)) + f(x) + x**4*f(x)**2,
+ False, 0, 0, 0
+ ),
+ # Test Non-Riccati ODEs
+ (
+ (1 - x**2)*f(x).diff(x, 2) - 2*x*f(x).diff(x) + 20*f(x),
+ False, 0, 0, 0
+ ),
+ (
+ f(x).diff(x) - x**2 + x**3*f(x) + (x**2/(x + 1))*f(x)**3,
+ False, 0, 0, 0
+ ),
+ (
+ f(x).diff(x)*f(x)**2 + (x**2 - 1)/(x**3 + 1)*f(x) + 1/(2*x \
+ + 3) + f(x)**2,
+ False, 0, 0, 0
+ )]
+ for eq, res, b0, b1, b2 in tests:
+ match, funcs = match_riccati(eq, f, x)
+ assert match == res
+ if res:
+ assert [b0, b1, b2] == funcs
+
+
+def test_val_at_inf():
+ """
+ This function tests the valuation of rational
+ function at oo.
+
+ Each test case has 3 values -
+
+ 1. num - Numerator of rational function.
+ 2. den - Denominator of rational function.
+ 3. val_inf - Valuation of rational function at oo
+ """
+ tests = [
+ # degree(denom) > degree(numer)
+ (
+ Poly(10*x**3 + 8*x**2 - 13*x + 6, x),
+ Poly(-13*x**10 - x**9 + 5*x**8 + 7*x**7 + 10*x**6 + 6*x**5 - 7*x**4 + 11*x**3 - 8*x**2 + 5*x + 13, x),
+ 7
+ ),
+ (
+ Poly(1, x),
+ Poly(-9*x**4 + 3*x**3 + 15*x**2 - 6*x - 14, x),
+ 4
+ ),
+ # degree(denom) == degree(numer)
+ (
+ Poly(-6*x**3 - 8*x**2 + 8*x - 6, x),
+ Poly(-5*x**3 + 12*x**2 - 6*x - 9, x),
+ 0
+ ),
+ # degree(denom) < degree(numer)
+ (
+ Poly(12*x**8 - 12*x**7 - 11*x**6 + 8*x**5 + 3*x**4 - x**3 + x**2 - 11*x, x),
+ Poly(-14*x**2 + x, x),
+ -6
+ ),
+ (
+ Poly(5*x**6 + 9*x**5 - 11*x**4 - 9*x**3 + x**2 - 4*x + 4, x),
+ Poly(15*x**4 + 3*x**3 - 8*x**2 + 15*x + 12, x),
+ -2
+ )]
+ for num, den, val in tests:
+ assert val_at_inf(num, den, x) == val
+
+
+def test_necessary_conds():
+ """
+ This function tests the necessary conditions for
+ a Riccati ODE to have a rational particular solution.
+ """
+ # Valuation at Infinity is an odd negative integer
+ assert check_necessary_conds(-3, [1, 2, 4]) == False
+ # Valuation at Infinity is a positive integer lesser than 2
+ assert check_necessary_conds(1, [1, 2, 4]) == False
+ # Multiplicity of a pole is an odd integer greater than 1
+ assert check_necessary_conds(2, [3, 1, 6]) == False
+ # All values are correct
+ assert check_necessary_conds(-10, [1, 2, 8, 12]) == True
+
+
+def test_inverse_transform_poly():
+ """
+ This function tests the substitution x -> 1/x
+ in rational functions represented using Poly.
+ """
+ fns = [
+ (15*x**3 - 8*x**2 - 2*x - 6)/(18*x + 6),
+
+ (180*x**5 + 40*x**4 + 80*x**3 + 30*x**2 - 60*x - 80)/(180*x**3 - 150*x**2 + 75*x + 12),
+
+ (-15*x**5 - 36*x**4 + 75*x**3 - 60*x**2 - 80*x - 60)/(80*x**4 + 60*x**3 + 60*x**2 + 60*x - 80),
+
+ (60*x**7 + 24*x**6 - 15*x**5 - 20*x**4 + 30*x**2 + 100*x - 60)/(240*x**2 - 20*x - 30),
+
+ (30*x**6 - 12*x**5 + 15*x**4 - 15*x**2 + 10*x + 60)/(3*x**10 - 45*x**9 + 15*x**5 + 15*x**4 - 5*x**3 \
+ + 15*x**2 + 45*x - 15)
+ ]
+ for f in fns:
+ num, den = [Poly(e, x) for e in f.as_numer_denom()]
+ num, den = inverse_transform_poly(num, den, x)
+ assert f.subs(x, 1/x).cancel() == num/den
+
+
+def test_limit_at_inf():
+ """
+ This function tests the limit at oo of a
+ rational function.
+
+ Each test case has 3 values -
+
+ 1. num - Numerator of rational function.
+ 2. den - Denominator of rational function.
+ 3. limit_at_inf - Limit of rational function at oo
+ """
+ tests = [
+ # deg(denom) > deg(numer)
+ (
+ Poly(-12*x**2 + 20*x + 32, x),
+ Poly(32*x**3 + 72*x**2 + 3*x - 32, x),
+ 0
+ ),
+ # deg(denom) < deg(numer)
+ (
+ Poly(1260*x**4 - 1260*x**3 - 700*x**2 - 1260*x + 1400, x),
+ Poly(6300*x**3 - 1575*x**2 + 756*x - 540, x),
+ oo
+ ),
+ # deg(denom) < deg(numer), one of the leading coefficients is negative
+ (
+ Poly(-735*x**8 - 1400*x**7 + 1680*x**6 - 315*x**5 - 600*x**4 + 840*x**3 - 525*x**2 \
+ + 630*x + 3780, x),
+ Poly(1008*x**7 - 2940*x**6 - 84*x**5 + 2940*x**4 - 420*x**3 + 1512*x**2 + 105*x + 168, x),
+ -oo
+ ),
+ # deg(denom) == deg(numer)
+ (
+ Poly(105*x**7 - 960*x**6 + 60*x**5 + 60*x**4 - 80*x**3 + 45*x**2 + 120*x + 15, x),
+ Poly(735*x**7 + 525*x**6 + 720*x**5 + 720*x**4 - 8400*x**3 - 2520*x**2 + 2800*x + 280, x),
+ S(1)/7
+ ),
+ (
+ Poly(288*x**4 - 450*x**3 + 280*x**2 - 900*x - 90, x),
+ Poly(607*x**4 + 840*x**3 - 1050*x**2 + 420*x + 420, x),
+ S(288)/607
+ )]
+ for num, den, lim in tests:
+ assert limit_at_inf(num, den, x) == lim
+
+
+def test_construct_c_case_1():
+ """
+ This function tests the Case 1 in the step
+ to calculate coefficients of c-vectors.
+
+ Each test case has 4 values -
+
+ 1. num - Numerator of the rational function a(x).
+ 2. den - Denominator of the rational function a(x).
+ 3. pole - Pole of a(x) for which c-vector is being
+ calculated.
+ 4. c - The c-vector for the pole.
+ """
+ tests = [
+ (
+ Poly(-3*x**3 + 3*x**2 + 4*x - 5, x, extension=True),
+ Poly(4*x**8 + 16*x**7 + 9*x**5 + 12*x**4 + 6*x**3 + 12*x**2, x, extension=True),
+ S(0),
+ [[S(1)/2 + sqrt(6)*I/6], [S(1)/2 - sqrt(6)*I/6]]
+ ),
+ (
+ Poly(1200*x**3 + 1440*x**2 + 816*x + 560, x, extension=True),
+ Poly(128*x**5 - 656*x**4 + 1264*x**3 - 1125*x**2 + 385*x + 49, x, extension=True),
+ S(7)/4,
+ [[S(1)/2 + sqrt(16367978)/634], [S(1)/2 - sqrt(16367978)/634]]
+ ),
+ (
+ Poly(4*x + 2, x, extension=True),
+ Poly(18*x**4 + (2 - 18*sqrt(3))*x**3 + (14 - 11*sqrt(3))*x**2 + (4 - 6*sqrt(3))*x \
+ + 8*sqrt(3) + 16, x, domain='QQ'),
+ (S(1) + sqrt(3))/2,
+ [[S(1)/2 + sqrt(Mul(4, 2*sqrt(3) + 4, evaluate=False)/(19*sqrt(3) + 44) + 1)/2], \
+ [S(1)/2 - sqrt(Mul(4, 2*sqrt(3) + 4, evaluate=False)/(19*sqrt(3) + 44) + 1)/2]]
+ )]
+ for num, den, pole, c in tests:
+ assert construct_c_case_1(num, den, x, pole) == c
+
+
+def test_construct_c_case_2():
+ """
+ This function tests the Case 2 in the step
+ to calculate coefficients of c-vectors.
+
+ Each test case has 5 values -
+
+ 1. num - Numerator of the rational function a(x).
+ 2. den - Denominator of the rational function a(x).
+ 3. pole - Pole of a(x) for which c-vector is being
+ calculated.
+ 4. mul - The multiplicity of the pole.
+ 5. c - The c-vector for the pole.
+ """
+ tests = [
+ # Testing poles with multiplicity 2
+ (
+ Poly(1, x, extension=True),
+ Poly((x - 1)**2*(x - 2), x, extension=True),
+ 1, 2,
+ [[-I*(-1 - I)/2], [I*(-1 + I)/2]]
+ ),
+ (
+ Poly(3*x**5 - 12*x**4 - 7*x**3 + 1, x, extension=True),
+ Poly((3*x - 1)**2*(x + 2)**2, x, extension=True),
+ S(1)/3, 2,
+ [[-S(89)/98], [-S(9)/98]]
+ ),
+ # Testing poles with multiplicity 4
+ (
+ Poly(x**3 - x**2 + 4*x, x, extension=True),
+ Poly((x - 2)**4*(x + 5)**2, x, extension=True),
+ 2, 4,
+ [[7*sqrt(3)*(S(60)/343 - 4*sqrt(3)/7)/12, 2*sqrt(3)/7], \
+ [-7*sqrt(3)*(S(60)/343 + 4*sqrt(3)/7)/12, -2*sqrt(3)/7]]
+ ),
+ (
+ Poly(3*x**5 + x**4 + 3, x, extension=True),
+ Poly((4*x + 1)**4*(x + 2), x, extension=True),
+ -S(1)/4, 4,
+ [[128*sqrt(439)*(-sqrt(439)/128 - S(55)/14336)/439, sqrt(439)/256], \
+ [-128*sqrt(439)*(sqrt(439)/128 - S(55)/14336)/439, -sqrt(439)/256]]
+ ),
+ # Testing poles with multiplicity 6
+ (
+ Poly(x**3 + 2, x, extension=True),
+ Poly((3*x - 1)**6*(x**2 + 1), x, extension=True),
+ S(1)/3, 6,
+ [[27*sqrt(66)*(-sqrt(66)/54 - S(131)/267300)/22, -2*sqrt(66)/1485, sqrt(66)/162], \
+ [-27*sqrt(66)*(sqrt(66)/54 - S(131)/267300)/22, 2*sqrt(66)/1485, -sqrt(66)/162]]
+ ),
+ (
+ Poly(x**2 + 12, x, extension=True),
+ Poly((x - sqrt(2))**6, x, extension=True),
+ sqrt(2), 6,
+ [[sqrt(14)*(S(6)/7 - 3*sqrt(14))/28, sqrt(7)/7, sqrt(14)], \
+ [-sqrt(14)*(S(6)/7 + 3*sqrt(14))/28, -sqrt(7)/7, -sqrt(14)]]
+ )]
+ for num, den, pole, mul, c in tests:
+ assert construct_c_case_2(num, den, x, pole, mul) == c
+
+
+def test_construct_c_case_3():
+ """
+ This function tests the Case 3 in the step
+ to calculate coefficients of c-vectors.
+ """
+ assert construct_c_case_3() == [[1]]
+
+
+def test_construct_d_case_4():
+ """
+ This function tests the Case 4 in the step
+ to calculate coefficients of the d-vector.
+
+ Each test case has 4 values -
+
+ 1. num - Numerator of the rational function a(x).
+ 2. den - Denominator of the rational function a(x).
+ 3. mul - Multiplicity of oo as a pole.
+ 4. d - The d-vector.
+ """
+ tests = [
+ # Tests with multiplicity at oo = 2
+ (
+ Poly(-x**5 - 2*x**4 + 4*x**3 + 2*x + 5, x, extension=True),
+ Poly(9*x**3 - 2*x**2 + 10*x - 2, x, extension=True),
+ 2,
+ [[10*I/27, I/3, -3*I*(S(158)/243 - I/3)/2], \
+ [-10*I/27, -I/3, 3*I*(S(158)/243 + I/3)/2]]
+ ),
+ (
+ Poly(-x**6 + 9*x**5 + 5*x**4 + 6*x**3 + 5*x**2 + 6*x + 7, x, extension=True),
+ Poly(x**4 + 3*x**3 + 12*x**2 - x + 7, x, extension=True),
+ 2,
+ [[-6*I, I, -I*(17 - I)/2], [6*I, -I, I*(17 + I)/2]]
+ ),
+ # Tests with multiplicity at oo = 4
+ (
+ Poly(-2*x**6 - x**5 - x**4 - 2*x**3 - x**2 - 3*x - 3, x, extension=True),
+ Poly(3*x**2 + 10*x + 7, x, extension=True),
+ 4,
+ [[269*sqrt(6)*I/288, -17*sqrt(6)*I/36, sqrt(6)*I/3, -sqrt(6)*I*(S(16969)/2592 \
+ - 2*sqrt(6)*I/3)/4], [-269*sqrt(6)*I/288, 17*sqrt(6)*I/36, -sqrt(6)*I/3, \
+ sqrt(6)*I*(S(16969)/2592 + 2*sqrt(6)*I/3)/4]]
+ ),
+ (
+ Poly(-3*x**5 - 3*x**4 - 3*x**3 - x**2 - 1, x, extension=True),
+ Poly(12*x - 2, x, extension=True),
+ 4,
+ [[41*I/192, 7*I/24, I/2, -I*(-S(59)/6912 - I)], \
+ [-41*I/192, -7*I/24, -I/2, I*(-S(59)/6912 + I)]]
+ ),
+ # Tests with multiplicity at oo = 4
+ (
+ Poly(-x**7 - x**5 - x**4 - x**2 - x, x, extension=True),
+ Poly(x + 2, x, extension=True),
+ 6,
+ [[-5*I/2, 2*I, -I, I, -I*(-9 - 3*I)/2], [5*I/2, -2*I, I, -I, I*(-9 + 3*I)/2]]
+ ),
+ (
+ Poly(-x**7 - x**6 - 2*x**5 - 2*x**4 - x**3 - x**2 + 2*x - 2, x, extension=True),
+ Poly(2*x - 2, x, extension=True),
+ 6,
+ [[3*sqrt(2)*I/4, 3*sqrt(2)*I/4, sqrt(2)*I/2, sqrt(2)*I/2, -sqrt(2)*I*(-S(7)/8 - \
+ 3*sqrt(2)*I/2)/2], [-3*sqrt(2)*I/4, -3*sqrt(2)*I/4, -sqrt(2)*I/2, -sqrt(2)*I/2, \
+ sqrt(2)*I*(-S(7)/8 + 3*sqrt(2)*I/2)/2]]
+ )]
+ for num, den, mul, d in tests:
+ ser = rational_laurent_series(num, den, x, oo, mul, 1)
+ assert construct_d_case_4(ser, mul//2) == d
+
+
+def test_construct_d_case_5():
+ """
+ This function tests the Case 5 in the step
+ to calculate coefficients of the d-vector.
+
+ Each test case has 3 values -
+
+ 1. num - Numerator of the rational function a(x).
+ 2. den - Denominator of the rational function a(x).
+ 3. d - The d-vector.
+ """
+ tests = [
+ (
+ Poly(2*x**3 + x**2 + x - 2, x, extension=True),
+ Poly(9*x**3 + 5*x**2 + 2*x - 1, x, extension=True),
+ [[sqrt(2)/3, -sqrt(2)/108], [-sqrt(2)/3, sqrt(2)/108]]
+ ),
+ (
+ Poly(3*x**5 + x**4 - x**3 + x**2 - 2*x - 2, x, domain='ZZ'),
+ Poly(9*x**5 + 7*x**4 + 3*x**3 + 2*x**2 + 5*x + 7, x, domain='ZZ'),
+ [[sqrt(3)/3, -2*sqrt(3)/27], [-sqrt(3)/3, 2*sqrt(3)/27]]
+ ),
+ (
+ Poly(x**2 - x + 1, x, domain='ZZ'),
+ Poly(3*x**2 + 7*x + 3, x, domain='ZZ'),
+ [[sqrt(3)/3, -5*sqrt(3)/9], [-sqrt(3)/3, 5*sqrt(3)/9]]
+ )]
+ for num, den, d in tests:
+ # Multiplicity of oo is 0
+ ser = rational_laurent_series(num, den, x, oo, 0, 1)
+ assert construct_d_case_5(ser) == d
+
+
+def test_construct_d_case_6():
+ """
+ This function tests the Case 6 in the step
+ to calculate coefficients of the d-vector.
+
+ Each test case has 3 values -
+
+ 1. num - Numerator of the rational function a(x).
+ 2. den - Denominator of the rational function a(x).
+ 3. d - The d-vector.
+ """
+ tests = [
+ (
+ Poly(-2*x**2 - 5, x, domain='ZZ'),
+ Poly(4*x**4 + 2*x**2 + 10*x + 2, x, domain='ZZ'),
+ [[S(1)/2 + I/2], [S(1)/2 - I/2]]
+ ),
+ (
+ Poly(-2*x**3 - 4*x**2 - 2*x - 5, x, domain='ZZ'),
+ Poly(x**6 - x**5 + 2*x**4 - 4*x**3 - 5*x**2 - 5*x + 9, x, domain='ZZ'),
+ [[1], [0]]
+ ),
+ (
+ Poly(-5*x**3 + x**2 + 11*x + 12, x, domain='ZZ'),
+ Poly(6*x**8 - 26*x**7 - 27*x**6 - 10*x**5 - 44*x**4 - 46*x**3 - 34*x**2 \
+ - 27*x - 42, x, domain='ZZ'),
+ [[1], [0]]
+ )]
+ for num, den, d in tests:
+ assert construct_d_case_6(num, den, x) == d
+
+
+def test_rational_laurent_series():
+ """
+ This function tests the computation of coefficients
+ of Laurent series of a rational function.
+
+ Each test case has 5 values -
+
+ 1. num - Numerator of the rational function.
+ 2. den - Denominator of the rational function.
+ 3. x0 - Point about which Laurent series is to
+ be calculated.
+ 4. mul - Multiplicity of x0 if x0 is a pole of
+ the rational function (0 otherwise).
+ 5. n - Number of terms upto which the series
+ is to be calculated.
+ """
+ tests = [
+ # Laurent series about simple pole (Multiplicity = 1)
+ (
+ Poly(x**2 - 3*x + 9, x, extension=True),
+ Poly(x**2 - x, x, extension=True),
+ S(1), 1, 6,
+ {1: 7, 0: -8, -1: 9, -2: -9, -3: 9, -4: -9}
+ ),
+ # Laurent series about multiple pole (Multiplicity > 1)
+ (
+ Poly(64*x**3 - 1728*x + 1216, x, extension=True),
+ Poly(64*x**4 - 80*x**3 - 831*x**2 + 1809*x - 972, x, extension=True),
+ S(9)/8, 2, 3,
+ {0: S(32177152)/46521675, 2: S(1019)/984, -1: S(11947565056)/28610830125, \
+ 1: S(209149)/75645}
+ ),
+ (
+ Poly(1, x, extension=True),
+ Poly(x**5 + (-4*sqrt(2) - 1)*x**4 + (4*sqrt(2) + 12)*x**3 + (-12 - 8*sqrt(2))*x**2 \
+ + (4 + 8*sqrt(2))*x - 4, x, extension=True),
+ sqrt(2), 4, 6,
+ {4: 1 + sqrt(2), 3: -3 - 2*sqrt(2), 2: Mul(-1, -3 - 2*sqrt(2), evaluate=False)/(-1 \
+ + sqrt(2)), 1: (-3 - 2*sqrt(2))/(-1 + sqrt(2))**2, 0: Mul(-1, -3 - 2*sqrt(2), evaluate=False \
+ )/(-1 + sqrt(2))**3, -1: (-3 - 2*sqrt(2))/(-1 + sqrt(2))**4}
+ ),
+ # Laurent series about oo
+ (
+ Poly(x**5 - 4*x**3 + 6*x**2 + 10*x - 13, x, extension=True),
+ Poly(x**2 - 5, x, extension=True),
+ oo, 3, 6,
+ {3: 1, 2: 0, 1: 1, 0: 6, -1: 15, -2: 17}
+ ),
+ # Laurent series at x0 where x0 is not a pole of the function
+ # Using multiplicity as 0 (as x0 will not be a pole)
+ (
+ Poly(3*x**3 + 6*x**2 - 2*x + 5, x, extension=True),
+ Poly(9*x**4 - x**3 - 3*x**2 + 4*x + 4, x, extension=True),
+ S(2)/5, 0, 1,
+ {0: S(3345)/3304, -1: S(399325)/2729104, -2: S(3926413375)/4508479808, \
+ -3: S(-5000852751875)/1862002160704, -4: S(-6683640101653125)/6152055138966016}
+ ),
+ (
+ Poly(-7*x**2 + 2*x - 4, x, extension=True),
+ Poly(7*x**5 + 9*x**4 + 8*x**3 + 3*x**2 + 6*x + 9, x, extension=True),
+ oo, 0, 6,
+ {0: 0, -2: 0, -5: -S(71)/49, -1: 0, -3: -1, -4: S(11)/7}
+ )]
+ for num, den, x0, mul, n, ser in tests:
+ assert ser == rational_laurent_series(num, den, x, x0, mul, n)
+
+
+def check_dummy_sol(eq, solse, dummy_sym):
+ """
+ Helper function to check if actual solution
+ matches expected solution if actual solution
+ contains dummy symbols.
+ """
+ if isinstance(eq, Eq):
+ eq = eq.lhs - eq.rhs
+ _, funcs = match_riccati(eq, f, x)
+
+ sols = solve_riccati(f(x), x, *funcs)
+ C1 = Dummy('C1')
+ sols = [sol.subs(C1, dummy_sym) for sol in sols]
+
+ assert all([x[0] for x in checkodesol(eq, sols)])
+ assert all([s1.dummy_eq(s2, dummy_sym) for s1, s2 in zip(sols, solse)])
+
+
+def test_solve_riccati():
+ """
+ This function tests the computation of rational
+ particular solutions for a Riccati ODE.
+
+ Each test case has 2 values -
+
+ 1. eq - Riccati ODE to be solved.
+ 2. sol - Expected solution to the equation.
+
+ Some examples have been taken from the paper - "Statistical Investigation of
+ First-Order Algebraic ODEs and their Rational General Solutions" by
+ Georg Grasegger, N. Thieu Vo, Franz Winkler
+
+ https://www3.risc.jku.at/publications/download/risc_5197/RISCReport15-19.pdf
+ """
+ C0 = Dummy('C0')
+ # Type: 1st Order Rational Riccati, dy/dx = a + b*y + c*y**2,
+ # a, b, c are rational functions of x
+
+ tests = [
+ # a(x) is a constant
+ (
+ Eq(f(x).diff(x) + f(x)**2 - 2, 0),
+ [Eq(f(x), sqrt(2)), Eq(f(x), -sqrt(2))]
+ ),
+ # a(x) is a constant
+ (
+ f(x)**2 + f(x).diff(x) + 4*f(x)/x + 2/x**2,
+ [Eq(f(x), (-2*C0 - x)/(C0*x + x**2))]
+ ),
+ # a(x) is a constant
+ (
+ 2*x**2*f(x).diff(x) - x*(4*f(x) + f(x).diff(x) - 4) + (f(x) - 1)*f(x),
+ [Eq(f(x), (C0 + 2*x**2)/(C0 + x))]
+ ),
+ # Pole with multiplicity 1
+ (
+ Eq(f(x).diff(x), -f(x)**2 - 2/(x**3 - x**2)),
+ [Eq(f(x), 1/(x**2 - x))]
+ ),
+ # One pole of multiplicity 2
+ (
+ x**2 - (2*x + 1/x)*f(x) + f(x)**2 + f(x).diff(x),
+ [Eq(f(x), (C0*x + x**3 + 2*x)/(C0 + x**2)), Eq(f(x), x)]
+ ),
+ (
+ x**4*f(x).diff(x) + x**2 - x*(2*f(x)**2 + f(x).diff(x)) + f(x),
+ [Eq(f(x), (C0*x**2 + x)/(C0 + x**2)), Eq(f(x), x**2)]
+ ),
+ # Multiple poles of multiplicity 2
+ (
+ -f(x)**2 + f(x).diff(x) + (15*x**2 - 20*x + 7)/((x - 1)**2*(2*x \
+ - 1)**2),
+ [Eq(f(x), (9*C0*x - 6*C0 - 15*x**5 + 60*x**4 - 94*x**3 + 72*x**2 \
+ - 30*x + 6)/(6*C0*x**2 - 9*C0*x + 3*C0 + 6*x**6 - 29*x**5 + \
+ 57*x**4 - 58*x**3 + 30*x**2 - 6*x)), Eq(f(x), (3*x - 2)/(2*x**2 \
+ - 3*x + 1))]
+ ),
+ # Regression: Poles with even multiplicity > 2 fixed
+ (
+ f(x)**2 + f(x).diff(x) - (4*x**6 - 8*x**5 + 12*x**4 + 4*x**3 + \
+ 7*x**2 - 20*x + 4)/(4*x**4),
+ [Eq(f(x), (2*x**5 - 2*x**4 - x**3 + 4*x**2 + 3*x - 2)/(2*x**4 \
+ - 2*x**2))]
+ ),
+ # Regression: Poles with even multiplicity > 2 fixed
+ (
+ Eq(f(x).diff(x), (-x**6 + 15*x**4 - 40*x**3 + 45*x**2 - 24*x + 4)/\
+ (x**12 - 12*x**11 + 66*x**10 - 220*x**9 + 495*x**8 - 792*x**7 + 924*x**6 - \
+ 792*x**5 + 495*x**4 - 220*x**3 + 66*x**2 - 12*x + 1) + f(x)**2 + f(x)),
+ [Eq(f(x), 1/(x**6 - 6*x**5 + 15*x**4 - 20*x**3 + 15*x**2 - 6*x + 1))]
+ ),
+ # More than 2 poles with multiplicity 2
+ # Regression: Fixed mistake in necessary conditions
+ (
+ Eq(f(x).diff(x), x*f(x) + 2*x + (3*x - 2)*f(x)**2/(4*x + 2) + \
+ (8*x**2 - 7*x + 26)/(16*x**3 - 24*x**2 + 8) - S(3)/2),
+ [Eq(f(x), (1 - 4*x)/(2*x - 2))]
+ ),
+ # Regression: Fixed mistake in necessary conditions
+ (
+ Eq(f(x).diff(x), (-12*x**2 - 48*x - 15)/(24*x**3 - 40*x**2 + 8*x + 8) \
+ + 3*f(x)**2/(6*x + 2)),
+ [Eq(f(x), (2*x + 1)/(2*x - 2))]
+ ),
+ # Imaginary poles
+ (
+ f(x).diff(x) + (3*x**2 + 1)*f(x)**2/x + (6*x**2 - x + 3)*f(x)/(x*(x \
+ - 1)) + (3*x**2 - 2*x + 2)/(x*(x - 1)**2),
+ [Eq(f(x), (-C0 - x**3 + x**2 - 2*x)/(C0*x - C0 + x**4 - x**3 + x**2 \
+ - x)), Eq(f(x), -1/(x - 1))],
+ ),
+ # Imaginary coefficients in equation
+ (
+ f(x).diff(x) - 2*I*(f(x)**2 + 1)/x,
+ [Eq(f(x), (-I*C0 + I*x**4)/(C0 + x**4)), Eq(f(x), -I)]
+ ),
+ # Regression: linsolve returning empty solution
+ # Large value of m (> 10)
+ (
+ Eq(f(x).diff(x), x*f(x)/(S(3)/2 - 2*x) + (x/2 - S(1)/3)*f(x)**2/\
+ (2*x/3 - S(1)/2) - S(5)/4 + (281*x**2 - 1260*x + 756)/(16*x**3 - 12*x**2)),
+ [Eq(f(x), (9 - x)/x), Eq(f(x), (40*x**14 + 28*x**13 + 420*x**12 + 2940*x**11 + \
+ 18480*x**10 + 103950*x**9 + 519750*x**8 + 2286900*x**7 + 8731800*x**6 + 28378350*\
+ x**5 + 76403250*x**4 + 163721250*x**3 + 261954000*x**2 + 278326125*x + 147349125)/\
+ ((24*x**14 + 140*x**13 + 840*x**12 + 4620*x**11 + 23100*x**10 + 103950*x**9 + \
+ 415800*x**8 + 1455300*x**7 + 4365900*x**6 + 10914750*x**5 + 21829500*x**4 + 32744250\
+ *x**3 + 32744250*x**2 + 16372125*x)))]
+ ),
+ # Regression: Fixed bug due to a typo in paper
+ (
+ Eq(f(x).diff(x), 18*x**3 + 18*x**2 + (-x/2 - S(1)/2)*f(x)**2 + 6),
+ [Eq(f(x), 6*x)]
+ ),
+ # Regression: Fixed bug due to a typo in paper
+ (
+ Eq(f(x).diff(x), -3*x**3/4 + 15*x/2 + (x/3 - S(4)/3)*f(x)**2 \
+ + 9 + (1 - x)*f(x)/x + 3/x),
+ [Eq(f(x), -3*x/2 - 3)]
+ )]
+ for eq, sol in tests:
+ check_dummy_sol(eq, sol, C0)
+
+
+@slow
+def test_solve_riccati_slow():
+ """
+ This function tests the computation of rational
+ particular solutions for a Riccati ODE.
+
+ Each test case has 2 values -
+
+ 1. eq - Riccati ODE to be solved.
+ 2. sol - Expected solution to the equation.
+ """
+ C0 = Dummy('C0')
+ tests = [
+ # Very large values of m (989 and 991)
+ (
+ Eq(f(x).diff(x), (1 - x)*f(x)/(x - 3) + (2 - 12*x)*f(x)**2/(2*x - 9) + \
+ (54924*x**3 - 405264*x**2 + 1084347*x - 1087533)/(8*x**4 - 132*x**3 + 810*x**2 - \
+ 2187*x + 2187) + 495),
+ [Eq(f(x), (18*x + 6)/(2*x - 9))]
+ )]
+ for eq, sol in tests:
+ check_dummy_sol(eq, sol, C0)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_single.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_single.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5ad37ae5a29f8d622fd81e1d4fcd9386e702865
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_single.py
@@ -0,0 +1,2897 @@
+#
+# The main tests for the code in single.py are currently located in
+# sympy/solvers/tests/test_ode.py
+#
+r"""
+This File contains test functions for the individual hints used for solving ODEs.
+
+Examples of each solver will be returned by _get_examples_ode_sol_name_of_solver.
+
+Examples should have a key 'XFAIL' which stores the list of hints if they are
+expected to fail for that hint.
+
+Functions that are for internal use:
+
+1) _ode_solver_test(ode_examples) - It takes a dictionary of examples returned by
+ _get_examples method and tests them with their respective hints.
+
+2) _test_particular_example(our_hint, example_name) - It tests the ODE example corresponding
+ to the hint provided.
+
+3) _test_all_hints(runxfail=False) - It is used to test all the examples with all the hints
+ currently implemented. It calls _test_all_examples_for_one_hint() which outputs whether the
+ given hint functions properly if it classifies the ODE example.
+ If runxfail flag is set to True then it will only test the examples which are expected to fail.
+
+ Everytime the ODE of a particular solver is added, _test_all_hints() is to be executed to find
+ the possible failures of different solver hints.
+
+4) _test_all_examples_for_one_hint(our_hint, all_examples) - It takes hint as argument and checks
+ this hint against all the ODE examples and gives output as the number of ODEs matched, number
+ of ODEs which were solved correctly, list of ODEs which gives incorrect solution and list of
+ ODEs which raises exception.
+
+"""
+from sympy.core.function import (Derivative, diff)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (E, I, Rational, pi)
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.exponential import (LambertW, exp, log)
+from sympy.functions.elementary.hyperbolic import (asinh, cosh, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import (cbrt, sqrt)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sec, sin, tan)
+from sympy.functions.special.error_functions import (Ei, erfi)
+from sympy.functions.special.hyper import hyper
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.polys.rootoftools import rootof
+
+from sympy.core import Function, Symbol
+from sympy.functions import airyai, airybi, besselj, bessely, lowergamma
+from sympy.integrals.risch import NonElementaryIntegral
+from sympy.solvers.ode import classify_ode, dsolve
+from sympy.solvers.ode.ode import allhints, _remove_redundant_solutions
+from sympy.solvers.ode.single import (FirstLinear, ODEMatchError,
+ SingleODEProblem, SingleODESolver, NthOrderReducible)
+
+from sympy.solvers.ode.subscheck import checkodesol
+
+from sympy.testing.pytest import raises, slow, ON_CI
+import traceback
+
+
+x = Symbol('x')
+u = Symbol('u')
+_u = Dummy('u')
+y = Symbol('y')
+f = Function('f')
+g = Function('g')
+C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 = symbols('C1:11')
+
+
+hint_message = """\
+Hint did not match the example {example}.
+
+The ODE is:
+{eq}.
+
+The expected hint was
+{our_hint}\
+"""
+
+expected_sol_message = """\
+Different solution found from dsolve for example {example}.
+
+The ODE is:
+{eq}
+
+The expected solution was
+{sol}
+
+What dsolve returned is:
+{dsolve_sol}\
+"""
+
+checkodesol_msg = """\
+solution found is not correct for example {example}.
+
+The ODE is:
+{eq}\
+"""
+
+dsol_incorrect_msg = """\
+solution returned by dsolve is incorrect when using {hint}.
+
+The ODE is:
+{eq}
+
+The expected solution was
+{sol}
+
+what dsolve returned is:
+{dsolve_sol}
+
+You can test this with:
+
+eq = {eq}
+sol = dsolve(eq, hint='{hint}')
+print(sol)
+print(checkodesol(eq, sol))
+
+"""
+
+exception_msg = """\
+dsolve raised exception : {e}
+
+when using {hint} for the example {example}
+
+You can test this with:
+
+from sympy.solvers.ode.tests.test_single import _test_an_example
+
+_test_an_example('{hint}', example_name = '{example}')
+
+The ODE is:
+{eq}
+
+\
+"""
+
+check_hint_msg = """\
+Tested hint was : {hint}
+
+Total of {matched} examples matched with this hint.
+
+Out of which {solve} gave correct results.
+
+Examples which gave incorrect results are {unsolve}.
+
+Examples which raised exceptions are {exceptions}
+\
+"""
+
+
+def _add_example_keys(func):
+ def inner():
+ solver=func()
+ examples=[]
+ for example in solver['examples']:
+ temp={
+ 'eq': solver['examples'][example]['eq'],
+ 'sol': solver['examples'][example]['sol'],
+ 'XFAIL': solver['examples'][example].get('XFAIL', []),
+ 'func': solver['examples'][example].get('func',solver['func']),
+ 'example_name': example,
+ 'slow': solver['examples'][example].get('slow', False),
+ 'simplify_flag':solver['examples'][example].get('simplify_flag',True),
+ 'checkodesol_XFAIL': solver['examples'][example].get('checkodesol_XFAIL', False),
+ 'dsolve_too_slow':solver['examples'][example].get('dsolve_too_slow',False),
+ 'checkodesol_too_slow':solver['examples'][example].get('checkodesol_too_slow',False),
+ 'hint': solver['hint']
+ }
+ examples.append(temp)
+ return examples
+ return inner()
+
+
+def _ode_solver_test(ode_examples, run_slow_test=False):
+ for example in ode_examples:
+ if ((not run_slow_test) and example['slow']) or (run_slow_test and (not example['slow'])):
+ continue
+
+ result = _test_particular_example(example['hint'], example, solver_flag=True)
+ if result['xpass_msg'] != "":
+ print(result['xpass_msg'])
+
+
+def _test_all_hints(runxfail=False):
+ all_hints = list(allhints)+["default"]
+ all_examples = _get_all_examples()
+
+ for our_hint in all_hints:
+ if our_hint.endswith('_Integral') or 'series' in our_hint:
+ continue
+ _test_all_examples_for_one_hint(our_hint, all_examples, runxfail)
+
+
+def _test_dummy_sol(expected_sol,dsolve_sol):
+ if type(dsolve_sol)==list:
+ return any(expected_sol.dummy_eq(sub_dsol) for sub_dsol in dsolve_sol)
+ else:
+ return expected_sol.dummy_eq(dsolve_sol)
+
+
+def _test_an_example(our_hint, example_name):
+ all_examples = _get_all_examples()
+ for example in all_examples:
+ if example['example_name'] == example_name:
+ _test_particular_example(our_hint, example)
+
+
+def _test_particular_example(our_hint, ode_example, solver_flag=False):
+ eq = ode_example['eq']
+ expected_sol = ode_example['sol']
+ example = ode_example['example_name']
+ xfail = our_hint in ode_example['XFAIL']
+ func = ode_example['func']
+ result = {'msg': '', 'xpass_msg': ''}
+ simplify_flag=ode_example['simplify_flag']
+ checkodesol_XFAIL = ode_example['checkodesol_XFAIL']
+ dsolve_too_slow = ode_example['dsolve_too_slow']
+ checkodesol_too_slow = ode_example['checkodesol_too_slow']
+ xpass = True
+ if solver_flag:
+ if our_hint not in classify_ode(eq, func):
+ message = hint_message.format(example=example, eq=eq, our_hint=our_hint)
+ raise AssertionError(message)
+
+ if our_hint in classify_ode(eq, func):
+ result['match_list'] = example
+ try:
+ if not (dsolve_too_slow):
+ dsolve_sol = dsolve(eq, func, simplify=simplify_flag,hint=our_hint)
+ else:
+ if len(expected_sol)==1:
+ dsolve_sol = expected_sol[0]
+ else:
+ dsolve_sol = expected_sol
+
+ except Exception as e:
+ dsolve_sol = []
+ result['exception_list'] = example
+ if not solver_flag:
+ traceback.print_exc()
+ result['msg'] = exception_msg.format(e=str(e), hint=our_hint, example=example, eq=eq)
+ if solver_flag and not xfail:
+ print(result['msg'])
+ raise
+ xpass = False
+
+ if solver_flag and dsolve_sol!=[]:
+ expect_sol_check = False
+ if type(dsolve_sol)==list:
+ for sub_sol in expected_sol:
+ if sub_sol.has(Dummy):
+ expect_sol_check = not _test_dummy_sol(sub_sol, dsolve_sol)
+ else:
+ expect_sol_check = sub_sol not in dsolve_sol
+ if expect_sol_check:
+ break
+ else:
+ expect_sol_check = dsolve_sol not in expected_sol
+ for sub_sol in expected_sol:
+ if sub_sol.has(Dummy):
+ expect_sol_check = not _test_dummy_sol(sub_sol, dsolve_sol)
+
+ if expect_sol_check:
+ message = expected_sol_message.format(example=example, eq=eq, sol=expected_sol, dsolve_sol=dsolve_sol)
+ raise AssertionError(message)
+
+ expected_checkodesol = [(True, 0) for i in range(len(expected_sol))]
+ if len(expected_sol) == 1:
+ expected_checkodesol = (True, 0)
+
+ if not (checkodesol_too_slow and ON_CI):
+ if not checkodesol_XFAIL:
+ if checkodesol(eq, dsolve_sol, func, solve_for_func=False) != expected_checkodesol:
+ result['unsolve_list'] = example
+ xpass = False
+ message = dsol_incorrect_msg.format(hint=our_hint, eq=eq, sol=expected_sol,dsolve_sol=dsolve_sol)
+ if solver_flag:
+ message = checkodesol_msg.format(example=example, eq=eq)
+ raise AssertionError(message)
+ else:
+ result['msg'] = 'AssertionError: ' + message
+
+ if xpass and xfail:
+ result['xpass_msg'] = example + "is now passing for the hint" + our_hint
+ return result
+
+
+def _test_all_examples_for_one_hint(our_hint, all_examples=[], runxfail=None):
+ if all_examples == []:
+ all_examples = _get_all_examples()
+ match_list, unsolve_list, exception_list = [], [], []
+ for ode_example in all_examples:
+ xfail = our_hint in ode_example['XFAIL']
+ if runxfail and not xfail:
+ continue
+ if xfail:
+ continue
+ result = _test_particular_example(our_hint, ode_example)
+ match_list += result.get('match_list',[])
+ unsolve_list += result.get('unsolve_list',[])
+ exception_list += result.get('exception_list',[])
+ if runxfail is not None:
+ msg = result['msg']
+ if msg!='':
+ print(result['msg'])
+ # print(result.get('xpass_msg',''))
+ if runxfail is None:
+ match_count = len(match_list)
+ solved = len(match_list)-len(unsolve_list)-len(exception_list)
+ msg = check_hint_msg.format(hint=our_hint, matched=match_count, solve=solved, unsolve=unsolve_list, exceptions=exception_list)
+ print(msg)
+
+
+def test_SingleODESolver():
+ # Test that not implemented methods give NotImplementedError
+ # Subclasses should override these methods.
+ problem = SingleODEProblem(f(x).diff(x), f(x), x)
+ solver = SingleODESolver(problem)
+ raises(NotImplementedError, lambda: solver.matches())
+ raises(NotImplementedError, lambda: solver.get_general_solution())
+ raises(NotImplementedError, lambda: solver._matches())
+ raises(NotImplementedError, lambda: solver._get_general_solution())
+
+ # This ODE can not be solved by the FirstLinear solver. Here we test that
+ # it does not match and the asking for a general solution gives
+ # ODEMatchError
+
+ problem = SingleODEProblem(f(x).diff(x) + f(x)*f(x), f(x), x)
+
+ solver = FirstLinear(problem)
+ raises(ODEMatchError, lambda: solver.get_general_solution())
+
+ solver = FirstLinear(problem)
+ assert solver.matches() is False
+
+ #These are just test for order of ODE
+
+ problem = SingleODEProblem(f(x).diff(x) + f(x), f(x), x)
+ assert problem.order == 1
+
+ problem = SingleODEProblem(f(x).diff(x,4) + f(x).diff(x,2) - f(x).diff(x,3), f(x), x)
+ assert problem.order == 4
+
+ problem = SingleODEProblem(f(x).diff(x, 3) + f(x).diff(x, 2) - f(x)**2, f(x), x)
+ assert problem.is_autonomous == True
+
+ problem = SingleODEProblem(f(x).diff(x, 3) + x*f(x).diff(x, 2) - f(x)**2, f(x), x)
+ assert problem.is_autonomous == False
+
+
+def test_linear_coefficients():
+ _ode_solver_test(_get_examples_ode_sol_linear_coefficients)
+
+
+@slow
+def test_1st_homogeneous_coeff_ode():
+ #These were marked as test_1st_homogeneous_coeff_corner_case
+ eq1 = f(x).diff(x) - f(x)/x
+ c1 = classify_ode(eq1, f(x))
+ eq2 = x*f(x).diff(x) - f(x)
+ c2 = classify_ode(eq2, f(x))
+ sdi = "1st_homogeneous_coeff_subs_dep_div_indep"
+ sid = "1st_homogeneous_coeff_subs_indep_div_dep"
+ assert sid not in c1 and sdi not in c1
+ assert sid not in c2 and sdi not in c2
+ _ode_solver_test(_get_examples_ode_sol_1st_homogeneous_coeff_subs_dep_div_indep)
+ _ode_solver_test(_get_examples_ode_sol_1st_homogeneous_coeff_best)
+
+
+@slow
+def test_slow_examples_1st_homogeneous_coeff_ode():
+ _ode_solver_test(_get_examples_ode_sol_1st_homogeneous_coeff_subs_dep_div_indep, run_slow_test=True)
+ _ode_solver_test(_get_examples_ode_sol_1st_homogeneous_coeff_best, run_slow_test=True)
+
+
+@slow
+def test_nth_linear_constant_coeff_homogeneous():
+ _ode_solver_test(_get_examples_ode_sol_nth_linear_constant_coeff_homogeneous)
+
+
+@slow
+def test_slow_examples_nth_linear_constant_coeff_homogeneous():
+ _ode_solver_test(_get_examples_ode_sol_nth_linear_constant_coeff_homogeneous, run_slow_test=True)
+
+
+def test_Airy_equation():
+ _ode_solver_test(_get_examples_ode_sol_2nd_linear_airy)
+
+
+@slow
+def test_lie_group():
+ _ode_solver_test(_get_examples_ode_sol_lie_group)
+
+
+@slow
+def test_separable_reduced():
+ df = f(x).diff(x)
+ eq = (x / f(x))*df + tan(x**2*f(x) / (x**2*f(x) - 1))
+ assert classify_ode(eq) == ('factorable', 'separable_reduced', 'lie_group',
+ 'separable_reduced_Integral')
+ _ode_solver_test(_get_examples_ode_sol_separable_reduced)
+
+
+@slow
+def test_slow_examples_separable_reduced():
+ _ode_solver_test(_get_examples_ode_sol_separable_reduced, run_slow_test=True)
+
+
+@slow
+def test_2nd_2F1_hypergeometric():
+ _ode_solver_test(_get_examples_ode_sol_2nd_2F1_hypergeometric)
+
+
+def test_2nd_2F1_hypergeometric_integral():
+ eq = x*(x-1)*f(x).diff(x, 2) + (-1+ S(7)/2*x)*f(x).diff(x) + f(x)
+ sol = Eq(f(x), (C1 + C2*Integral(exp(Integral((1 - x/2)/(x*(x - 1)), x))/(1 -
+ x/2)**2, x))*exp(Integral(1/(x - 1), x)/4)*exp(-Integral(7/(x -
+ 1), x)/4)*hyper((S(1)/2, -1), (1,), x))
+ assert sol == dsolve(eq, hint='2nd_hypergeometric_Integral')
+ assert checkodesol(eq, sol) == (True, 0)
+
+
+@slow
+def test_2nd_nonlinear_autonomous_conserved():
+ _ode_solver_test(_get_examples_ode_sol_2nd_nonlinear_autonomous_conserved)
+
+
+def test_2nd_nonlinear_autonomous_conserved_integral():
+ eq = f(x).diff(x, 2) + asin(f(x))
+ actual = [Eq(Integral(1/sqrt(C1 - 2*Integral(asin(_u), _u)), (_u, f(x))), C2 + x),
+ Eq(Integral(1/sqrt(C1 - 2*Integral(asin(_u), _u)), (_u, f(x))), C2 - x)]
+ solved = dsolve(eq, hint='2nd_nonlinear_autonomous_conserved_Integral', simplify=False)
+ for a,s in zip(actual, solved):
+ assert a.dummy_eq(s)
+ # checkodesol unable to simplify solutions with f(x) in an integral equation
+ assert checkodesol(eq, [s.doit() for s in solved]) == [(True, 0), (True, 0)]
+
+
+@slow
+def test_2nd_linear_bessel_equation():
+ _ode_solver_test(_get_examples_ode_sol_2nd_linear_bessel)
+
+
+@slow
+def test_nth_algebraic():
+ eqn = f(x) + f(x)*f(x).diff(x)
+ solns = [Eq(f(x), exp(x)),
+ Eq(f(x), C1*exp(C2*x))]
+ solns_final = _remove_redundant_solutions(eqn, solns, 2, x)
+ assert solns_final == [Eq(f(x), C1*exp(C2*x))]
+
+ _ode_solver_test(_get_examples_ode_sol_nth_algebraic)
+
+
+@slow
+def test_slow_examples_nth_linear_constant_coeff_var_of_parameters():
+ _ode_solver_test(_get_examples_ode_sol_nth_linear_var_of_parameters, run_slow_test=True)
+
+
+def test_nth_linear_constant_coeff_var_of_parameters():
+ _ode_solver_test(_get_examples_ode_sol_nth_linear_var_of_parameters)
+
+
+@slow
+def test_nth_linear_constant_coeff_variation_of_parameters__integral():
+ # solve_variation_of_parameters shouldn't attempt to simplify the
+ # Wronskian if simplify=False. If wronskian() ever gets good enough
+ # to simplify the result itself, this test might fail.
+ our_hint = 'nth_linear_constant_coeff_variation_of_parameters_Integral'
+ eq = f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x) - 2*x - exp(I*x)
+ sol_simp = dsolve(eq, f(x), hint=our_hint, simplify=True)
+ sol_nsimp = dsolve(eq, f(x), hint=our_hint, simplify=False)
+ assert sol_simp != sol_nsimp
+ assert checkodesol(eq, sol_simp, order=5, solve_for_func=False) == (True, 0)
+ assert checkodesol(eq, sol_simp, order=5, solve_for_func=False) == (True, 0)
+
+
+@slow
+def test_slow_examples_1st_exact():
+ _ode_solver_test(_get_examples_ode_sol_1st_exact, run_slow_test=True)
+
+
+@slow
+def test_1st_exact():
+ _ode_solver_test(_get_examples_ode_sol_1st_exact)
+
+
+def test_1st_exact_integral():
+ eq = cos(f(x)) - (x*sin(f(x)) - f(x)**2)*f(x).diff(x)
+ sol_1 = dsolve(eq, f(x), simplify=False, hint='1st_exact_Integral')
+ assert checkodesol(eq, sol_1, order=1, solve_for_func=False)
+
+
+@slow
+def test_slow_examples_nth_order_reducible():
+ _ode_solver_test(_get_examples_ode_sol_nth_order_reducible, run_slow_test=True)
+
+
+@slow
+def test_slow_examples_nth_linear_constant_coeff_undetermined_coefficients():
+ _ode_solver_test(_get_examples_ode_sol_nth_linear_undetermined_coefficients, run_slow_test=True)
+
+
+@slow
+def test_slow_examples_separable():
+ _ode_solver_test(_get_examples_ode_sol_separable, run_slow_test=True)
+
+
+@slow
+def test_nth_linear_constant_coeff_undetermined_coefficients():
+ #issue-https://github.com/sympy/sympy/issues/5787
+ # This test case is to show the classification of imaginary constants under
+ # nth_linear_constant_coeff_undetermined_coefficients
+ eq = Eq(diff(f(x), x), I*f(x) + S.Half - I)
+ our_hint = 'nth_linear_constant_coeff_undetermined_coefficients'
+ assert our_hint in classify_ode(eq)
+ _ode_solver_test(_get_examples_ode_sol_nth_linear_undetermined_coefficients)
+
+
+def test_nth_order_reducible():
+ F = lambda eq: NthOrderReducible(SingleODEProblem(eq, f(x), x))._matches()
+ D = Derivative
+ assert F(D(y*f(x), x, y) + D(f(x), x)) == False
+ assert F(D(y*f(y), y, y) + D(f(y), y)) == False
+ assert F(f(x)*D(f(x), x) + D(f(x), x, 2))== False
+ assert F(D(x*f(y), y, 2) + D(u*y*f(x), x, 3)) == False # no simplification by design
+ assert F(D(f(y), y, 2) + D(f(y), y, 3) + D(f(x), x, 4)) == False
+ assert F(D(f(x), x, 2) + D(f(x), x, 3)) == True
+ _ode_solver_test(_get_examples_ode_sol_nth_order_reducible)
+
+
+@slow
+def test_separable():
+ _ode_solver_test(_get_examples_ode_sol_separable)
+
+
+@slow
+def test_factorable():
+ assert integrate(-asin(f(2*x)+pi), x) == -Integral(asin(pi + f(2*x)), x)
+ _ode_solver_test(_get_examples_ode_sol_factorable)
+
+
+@slow
+def test_slow_examples_factorable():
+ _ode_solver_test(_get_examples_ode_sol_factorable, run_slow_test=True)
+
+
+def test_Riccati_special_minus2():
+ _ode_solver_test(_get_examples_ode_sol_riccati)
+
+
+@slow
+def test_1st_rational_riccati():
+ _ode_solver_test(_get_examples_ode_sol_1st_rational_riccati)
+
+
+def test_Bernoulli():
+ _ode_solver_test(_get_examples_ode_sol_bernoulli)
+
+
+def test_1st_linear():
+ _ode_solver_test(_get_examples_ode_sol_1st_linear)
+
+
+def test_almost_linear():
+ _ode_solver_test(_get_examples_ode_sol_almost_linear)
+
+
+@slow
+def test_Liouville_ODE():
+ hint = 'Liouville'
+ not_Liouville1 = classify_ode(diff(f(x), x)/x + f(x)*diff(f(x), x, x)/2 -
+ diff(f(x), x)**2/2, f(x))
+ not_Liouville2 = classify_ode(diff(f(x), x)/x + diff(f(x), x, x)/2 -
+ x*diff(f(x), x)**2/2, f(x))
+ assert hint not in not_Liouville1
+ assert hint not in not_Liouville2
+ assert hint + '_Integral' not in not_Liouville1
+ assert hint + '_Integral' not in not_Liouville2
+
+ _ode_solver_test(_get_examples_ode_sol_liouville)
+
+
+def test_nth_order_linear_euler_eq_homogeneous():
+ x, t, a, b, c = symbols('x t a b c')
+ y = Function('y')
+ our_hint = "nth_linear_euler_eq_homogeneous"
+
+ eq = diff(f(t), t, 4)*t**4 - 13*diff(f(t), t, 2)*t**2 + 36*f(t)
+ assert our_hint in classify_ode(eq)
+
+ eq = a*y(t) + b*t*diff(y(t), t) + c*t**2*diff(y(t), t, 2)
+ assert our_hint in classify_ode(eq)
+
+ _ode_solver_test(_get_examples_ode_sol_euler_homogeneous)
+
+
+def test_nth_order_linear_euler_eq_nonhomogeneous_undetermined_coefficients():
+ x, t = symbols('x t')
+ a, b, c, d = symbols('a b c d', integer=True)
+ our_hint = "nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients"
+
+ eq = x**4*diff(f(x), x, 4) - 13*x**2*diff(f(x), x, 2) + 36*f(x) + x
+ assert our_hint in classify_ode(eq, f(x))
+
+ eq = a*x**2*diff(f(x), x, 2) + b*x*diff(f(x), x) + c*f(x) + d*log(x)
+ assert our_hint in classify_ode(eq, f(x))
+
+ _ode_solver_test(_get_examples_ode_sol_euler_undetermined_coeff)
+
+
+@slow
+def test_nth_order_linear_euler_eq_nonhomogeneous_variation_of_parameters():
+ x, t = symbols('x, t')
+ a, b, c, d = symbols('a, b, c, d', integer=True)
+ our_hint = "nth_linear_euler_eq_nonhomogeneous_variation_of_parameters"
+
+ eq = Eq(x**2*diff(f(x),x,2) - 8*x*diff(f(x),x) + 12*f(x), x**2)
+ assert our_hint in classify_ode(eq, f(x))
+
+ eq = Eq(a*x**3*diff(f(x),x,3) + b*x**2*diff(f(x),x,2) + c*x*diff(f(x),x) + d*f(x), x*log(x))
+ assert our_hint in classify_ode(eq, f(x))
+
+ _ode_solver_test(_get_examples_ode_sol_euler_var_para)
+
+
+@_add_example_keys
+def _get_examples_ode_sol_euler_homogeneous():
+ r1, r2, r3, r4, r5 = [rootof(x**5 - 14*x**4 + 71*x**3 - 154*x**2 + 120*x - 1, n) for n in range(5)]
+ return {
+ 'hint': "nth_linear_euler_eq_homogeneous",
+ 'func': f(x),
+ 'examples':{
+ 'euler_hom_01': {
+ 'eq': Eq(-3*diff(f(x), x)*x + 2*x**2*diff(f(x), x, x), 0),
+ 'sol': [Eq(f(x), C1 + C2*x**Rational(5, 2))],
+ },
+
+ 'euler_hom_02': {
+ 'eq': Eq(3*f(x) - 5*diff(f(x), x)*x + 2*x**2*diff(f(x), x, x), 0),
+ 'sol': [Eq(f(x), C1*sqrt(x) + C2*x**3)]
+ },
+
+ 'euler_hom_03': {
+ 'eq': Eq(4*f(x) + 5*diff(f(x), x)*x + x**2*diff(f(x), x, x), 0),
+ 'sol': [Eq(f(x), (C1 + C2*log(x))/x**2)]
+ },
+
+ 'euler_hom_04': {
+ 'eq': Eq(6*f(x) - 6*diff(f(x), x)*x + 1*x**2*diff(f(x), x, x) + x**3*diff(f(x), x, x, x), 0),
+ 'sol': [Eq(f(x), C1/x**2 + C2*x + C3*x**3)]
+ },
+
+ 'euler_hom_05': {
+ 'eq': Eq(-125*f(x) + 61*diff(f(x), x)*x - 12*x**2*diff(f(x), x, x) + x**3*diff(f(x), x, x, x), 0),
+ 'sol': [Eq(f(x), x**5*(C1 + C2*log(x) + C3*log(x)**2))]
+ },
+
+ 'euler_hom_06': {
+ 'eq': x**2*diff(f(x), x, 2) + x*diff(f(x), x) - 9*f(x),
+ 'sol': [Eq(f(x), C1*x**-3 + C2*x**3)]
+ },
+
+ 'euler_hom_07': {
+ 'eq': sin(x)*x**2*f(x).diff(x, 2) + sin(x)*x*f(x).diff(x) + sin(x)*f(x),
+ 'sol': [Eq(f(x), C1*sin(log(x)) + C2*cos(log(x)))],
+ 'XFAIL': ['2nd_power_series_regular','nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients']
+ },
+
+ 'euler_hom_08': {
+ 'eq': x**6 * f(x).diff(x, 6) - x*f(x).diff(x) + f(x),
+ 'sol': [Eq(f(x), C1*x + C2*x**r1 + C3*x**r2 + C4*x**r3 + C5*x**r4 + C6*x**r5)],
+ 'checkodesol_XFAIL':True
+ },
+
+ #This example is from issue: https://github.com/sympy/sympy/issues/15237 #This example is from issue:
+ # https://github.com/sympy/sympy/issues/15237
+ 'euler_hom_09': {
+ 'eq': Derivative(x*f(x), x, x, x),
+ 'sol': [Eq(f(x), C1 + C2/x + C3*x)],
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_euler_undetermined_coeff():
+ return {
+ 'hint': "nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients",
+ 'func': f(x),
+ 'examples':{
+ 'euler_undet_01': {
+ 'eq': Eq(x**2*diff(f(x), x, x) + x*diff(f(x), x), 1),
+ 'sol': [Eq(f(x), C1 + C2*log(x) + log(x)**2/2)]
+ },
+
+ 'euler_undet_02': {
+ 'eq': Eq(x**2*diff(f(x), x, x) - 2*x*diff(f(x), x) + 2*f(x), x**3),
+ 'sol': [Eq(f(x), x*(C1 + C2*x + Rational(1, 2)*x**2))]
+ },
+
+ 'euler_undet_03': {
+ 'eq': Eq(x**2*diff(f(x), x, x) - x*diff(f(x), x) - 3*f(x), log(x)/x),
+ 'sol': [Eq(f(x), (C1 + C2*x**4 - log(x)**2/8 - log(x)/16)/x)]
+ },
+
+ 'euler_undet_04': {
+ 'eq': Eq(x**2*diff(f(x), x, x) + 3*x*diff(f(x), x) - 8*f(x), log(x)**3 - log(x)),
+ 'sol': [Eq(f(x), C1/x**4 + C2*x**2 - Rational(1,8)*log(x)**3 - Rational(3,32)*log(x)**2 - Rational(1,64)*log(x) - Rational(7, 256))]
+ },
+
+ 'euler_undet_05': {
+ 'eq': Eq(x**3*diff(f(x), x, x, x) - 3*x**2*diff(f(x), x, x) + 6*x*diff(f(x), x) - 6*f(x), log(x)),
+ 'sol': [Eq(f(x), C1*x + C2*x**2 + C3*x**3 - Rational(1, 6)*log(x) - Rational(11, 36))]
+ },
+
+ #Below examples were added for the issue: https://github.com/sympy/sympy/issues/5096
+ 'euler_undet_06': {
+ 'eq': 2*x**2*f(x).diff(x, 2) + f(x) + sqrt(2*x)*sin(log(2*x)/2),
+ 'sol': [Eq(f(x), sqrt(x)*(C1*sin(log(x)/2) + C2*cos(log(x)/2) + sqrt(2)*log(x)*cos(log(2*x)/2)/2))]
+ },
+
+ 'euler_undet_07': {
+ 'eq': 2*x**2*f(x).diff(x, 2) + f(x) + sin(log(2*x)/2),
+ 'sol': [Eq(f(x), C1*sqrt(x)*sin(log(x)/2) + C2*sqrt(x)*cos(log(x)/2) - 2*sin(log(2*x)/2)/5 - 4*cos(log(2*x)/2)/5)]
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_euler_var_para():
+ return {
+ 'hint': "nth_linear_euler_eq_nonhomogeneous_variation_of_parameters",
+ 'func': f(x),
+ 'examples':{
+ 'euler_var_01': {
+ 'eq': Eq(x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x), x**4),
+ 'sol': [Eq(f(x), x*(C1 + C2*x + x**3/6))]
+ },
+
+ 'euler_var_02': {
+ 'eq': Eq(3*x**2*diff(f(x), x, x) + 6*x*diff(f(x), x) - 6*f(x), x**3*exp(x)),
+ 'sol': [Eq(f(x), C1/x**2 + C2*x + x*exp(x)/3 - 4*exp(x)/3 + 8*exp(x)/(3*x) - 8*exp(x)/(3*x**2))]
+ },
+
+ 'euler_var_03': {
+ 'eq': Eq(x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x), x**4*exp(x)),
+ 'sol': [Eq(f(x), x*(C1 + C2*x + x*exp(x) - 2*exp(x)))]
+ },
+
+ 'euler_var_04': {
+ 'eq': x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x) - log(x),
+ 'sol': [Eq(f(x), C1*x + C2*x**2 + log(x)/2 + Rational(3, 4))]
+ },
+
+ 'euler_var_05': {
+ 'eq': -exp(x) + (x*Derivative(f(x), (x, 2)) + Derivative(f(x), x))/x,
+ 'sol': [Eq(f(x), C1 + C2*log(x) + exp(x) - Ei(x))]
+ },
+
+ 'euler_var_06': {
+ 'eq': x**2 * f(x).diff(x, 2) + x * f(x).diff(x) + 4 * f(x) - 1/x,
+ 'sol': [Eq(f(x), C1*sin(2*log(x)) + C2*cos(2*log(x)) + 1/(5*x))]
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_bernoulli():
+ # Type: Bernoulli, f'(x) + p(x)*f(x) == q(x)*f(x)**n
+ return {
+ 'hint': "Bernoulli",
+ 'func': f(x),
+ 'examples':{
+ 'bernoulli_01': {
+ 'eq': Eq(x*f(x).diff(x) + f(x) - f(x)**2, 0),
+ 'sol': [Eq(f(x), 1/(C1*x + 1))],
+ 'XFAIL': ['separable_reduced']
+ },
+
+ 'bernoulli_02': {
+ 'eq': f(x).diff(x) - y*f(x),
+ 'sol': [Eq(f(x), C1*exp(x*y))]
+ },
+
+ 'bernoulli_03': {
+ 'eq': f(x)*f(x).diff(x) - 1,
+ 'sol': [Eq(f(x), -sqrt(C1 + 2*x)), Eq(f(x), sqrt(C1 + 2*x))]
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_riccati():
+ # Type: Riccati special alpha = -2, a*dy/dx + b*y**2 + c*y/x +d/x**2
+ return {
+ 'hint': "Riccati_special_minus2",
+ 'func': f(x),
+ 'examples':{
+ 'riccati_01': {
+ 'eq': 2*f(x).diff(x) + f(x)**2 - f(x)/x + 3*x**(-2),
+ 'sol': [Eq(f(x), (-sqrt(3)*tan(C1 + sqrt(3)*log(x)/4) + 3)/(2*x))],
+ },
+ },
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_1st_rational_riccati():
+ # Type: 1st Order Rational Riccati, dy/dx = a + b*y + c*y**2,
+ # a, b, c are rational functions of x
+ return {
+ 'hint': "1st_rational_riccati",
+ 'func': f(x),
+ 'examples':{
+ # a(x) is a constant
+ "rational_riccati_01": {
+ "eq": Eq(f(x).diff(x) + f(x)**2 - 2, 0),
+ "sol": [Eq(f(x), sqrt(2)*(-C1 - exp(2*sqrt(2)*x))/(C1 - exp(2*sqrt(2)*x)))]
+ },
+ # a(x) is a constant
+ "rational_riccati_02": {
+ "eq": f(x)**2 + Derivative(f(x), x) + 4*f(x)/x + 2/x**2,
+ "sol": [Eq(f(x), (-2*C1 - x)/(x*(C1 + x)))]
+ },
+ # a(x) is a constant
+ "rational_riccati_03": {
+ "eq": 2*x**2*Derivative(f(x), x) - x*(4*f(x) + Derivative(f(x), x) - 4) + (f(x) - 1)*f(x),
+ "sol": [Eq(f(x), (C1 + 2*x**2)/(C1 + x))]
+ },
+ # Constant coefficients
+ "rational_riccati_04": {
+ "eq": f(x).diff(x) - 6 - 5*f(x) - f(x)**2,
+ "sol": [Eq(f(x), (-2*C1 + 3*exp(x))/(C1 - exp(x)))]
+ },
+ # One pole of multiplicity 2
+ "rational_riccati_05": {
+ "eq": x**2 - (2*x + 1/x)*f(x) + f(x)**2 + Derivative(f(x), x),
+ "sol": [Eq(f(x), x*(C1 + x**2 + 1)/(C1 + x**2 - 1))]
+ },
+ # One pole of multiplicity 2
+ "rational_riccati_06": {
+ "eq": x**4*Derivative(f(x), x) + x**2 - x*(2*f(x)**2 + Derivative(f(x), x)) + f(x),
+ "sol": [Eq(f(x), x*(C1*x - x + 1)/(C1 + x**2 - 1))]
+ },
+ # Multiple poles of multiplicity 2
+ "rational_riccati_07": {
+ "eq": -f(x)**2 + Derivative(f(x), x) + (15*x**2 - 20*x + 7)/((x - 1)**2*(2*x \
+ - 1)**2),
+ "sol": [Eq(f(x), (9*C1*x - 6*C1 - 15*x**5 + 60*x**4 - 94*x**3 + 72*x**2 - \
+ 33*x + 8)/(6*C1*x**2 - 9*C1*x + 3*C1 + 6*x**6 - 29*x**5 + 57*x**4 - \
+ 58*x**3 + 28*x**2 - 3*x - 1))]
+ },
+ # Imaginary poles
+ "rational_riccati_08": {
+ "eq": Derivative(f(x), x) + (3*x**2 + 1)*f(x)**2/x + (6*x**2 - x + 3)*f(x)/(x*(x \
+ - 1)) + (3*x**2 - 2*x + 2)/(x*(x - 1)**2),
+ "sol": [Eq(f(x), (-C1 - x**3 + x**2 - 2*x + 1)/(C1*x - C1 + x**4 - x**3 + x**2 - \
+ 2*x + 1))],
+ },
+ # Imaginary coefficients in equation
+ "rational_riccati_09": {
+ "eq": Derivative(f(x), x) - 2*I*(f(x)**2 + 1)/x,
+ "sol": [Eq(f(x), (-I*C1 + I*x**4 + I)/(C1 + x**4 - 1))]
+ },
+ # Regression: linsolve returning empty solution
+ # Large value of m (> 10)
+ "rational_riccati_10": {
+ "eq": Eq(Derivative(f(x), x), x*f(x)/(S(3)/2 - 2*x) + (x/2 - S(1)/3)*f(x)**2/\
+ (2*x/3 - S(1)/2) - S(5)/4 + (281*x**2 - 1260*x + 756)/(16*x**3 - 12*x**2)),
+ "sol": [Eq(f(x), (40*C1*x**14 + 28*C1*x**13 + 420*C1*x**12 + 2940*C1*x**11 + \
+ 18480*C1*x**10 + 103950*C1*x**9 + 519750*C1*x**8 + 2286900*C1*x**7 + \
+ 8731800*C1*x**6 + 28378350*C1*x**5 + 76403250*C1*x**4 + 163721250*C1*x**3 \
+ + 261954000*C1*x**2 + 278326125*C1*x + 147349125*C1 + x*exp(2*x) - 9*exp(2*x) \
+ )/(x*(24*C1*x**13 + 140*C1*x**12 + 840*C1*x**11 + 4620*C1*x**10 + 23100*C1*x**9 \
+ + 103950*C1*x**8 + 415800*C1*x**7 + 1455300*C1*x**6 + 4365900*C1*x**5 + \
+ 10914750*C1*x**4 + 21829500*C1*x**3 + 32744250*C1*x**2 + 32744250*C1*x + \
+ 16372125*C1 - exp(2*x))))]
+ }
+ }
+ }
+
+
+
+@_add_example_keys
+def _get_examples_ode_sol_1st_linear():
+ # Type: first order linear form f'(x)+p(x)f(x)=q(x)
+ return {
+ 'hint': "1st_linear",
+ 'func': f(x),
+ 'examples':{
+ 'linear_01': {
+ 'eq': Eq(f(x).diff(x) + x*f(x), x**2),
+ 'sol': [Eq(f(x), (C1 + x*exp(x**2/2)- sqrt(2)*sqrt(pi)*erfi(sqrt(2)*x/2)/2)*exp(-x**2/2))],
+ },
+ },
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_factorable():
+ """ some hints are marked as xfail for examples because they missed additional algebraic solution
+ which could be found by Factorable hint. Fact_01 raise exception for
+ nth_linear_constant_coeff_undetermined_coefficients"""
+
+ y = Dummy('y')
+ a0,a1,a2,a3,a4 = symbols('a0, a1, a2, a3, a4')
+ return {
+ 'hint': "factorable",
+ 'func': f(x),
+ 'examples':{
+ 'fact_01': {
+ 'eq': f(x) + f(x)*f(x).diff(x),
+ 'sol': [Eq(f(x), 0), Eq(f(x), C1 - x)],
+ 'XFAIL': ['separable', '1st_exact', '1st_linear', 'Bernoulli', '1st_homogeneous_coeff_best',
+ '1st_homogeneous_coeff_subs_indep_div_dep', '1st_homogeneous_coeff_subs_dep_div_indep',
+ 'lie_group', 'nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients',
+ 'nth_linear_constant_coeff_variation_of_parameters',
+ 'nth_linear_euler_eq_nonhomogeneous_variation_of_parameters',
+ 'nth_linear_constant_coeff_undetermined_coefficients']
+ },
+
+ 'fact_02': {
+ 'eq': f(x)*(f(x).diff(x)+f(x)*x+2),
+ 'sol': [Eq(f(x), (C1 - sqrt(2)*sqrt(pi)*erfi(sqrt(2)*x/2))*exp(-x**2/2)), Eq(f(x), 0)],
+ 'XFAIL': ['Bernoulli', '1st_linear', 'lie_group']
+ },
+
+ 'fact_03': {
+ 'eq': (f(x).diff(x)+f(x)*x**2)*(f(x).diff(x, 2) + x*f(x)),
+ 'sol': [Eq(f(x), C1*airyai(-x) + C2*airybi(-x)),Eq(f(x), C1*exp(-x**3/3))]
+ },
+
+ 'fact_04': {
+ 'eq': (f(x).diff(x)+f(x)*x**2)*(f(x).diff(x, 2) + f(x)),
+ 'sol': [Eq(f(x), C1*exp(-x**3/3)), Eq(f(x), C1*sin(x) + C2*cos(x))]
+ },
+
+ 'fact_05': {
+ 'eq': (f(x).diff(x)**2-1)*(f(x).diff(x)**2-4),
+ 'sol': [Eq(f(x), C1 - x), Eq(f(x), C1 + x), Eq(f(x), C1 + 2*x), Eq(f(x), C1 - 2*x)]
+ },
+
+ 'fact_06': {
+ 'eq': (f(x).diff(x, 2)-exp(f(x)))*f(x).diff(x),
+ 'sol': [
+ Eq(f(x), log(-C1/(cos(sqrt(-C1)*(C2 + x)) + 1))),
+ Eq(f(x), log(-C1/(cos(sqrt(-C1)*(C2 - x)) + 1))),
+ Eq(f(x), C1)
+ ],
+ 'slow': True,
+ },
+
+ 'fact_07': {
+ 'eq': (f(x).diff(x)**2-1)*(f(x)*f(x).diff(x)-1),
+ 'sol': [Eq(f(x), C1 - x), Eq(f(x), -sqrt(C1 + 2*x)),Eq(f(x), sqrt(C1 + 2*x)), Eq(f(x), C1 + x)]
+ },
+
+ 'fact_08': {
+ 'eq': Derivative(f(x), x)**4 - 2*Derivative(f(x), x)**2 + 1,
+ 'sol': [Eq(f(x), C1 - x), Eq(f(x), C1 + x)]
+ },
+
+ 'fact_09': {
+ 'eq': f(x)**2*Derivative(f(x), x)**6 - 2*f(x)**2*Derivative(f(x),
+ x)**4 + f(x)**2*Derivative(f(x), x)**2 - 2*f(x)*Derivative(f(x),
+ x)**5 + 4*f(x)*Derivative(f(x), x)**3 - 2*f(x)*Derivative(f(x),
+ x) + Derivative(f(x), x)**4 - 2*Derivative(f(x), x)**2 + 1,
+ 'sol': [
+ Eq(f(x), C1 - x), Eq(f(x), -sqrt(C1 + 2*x)),
+ Eq(f(x), sqrt(C1 + 2*x)), Eq(f(x), C1 + x)
+ ]
+ },
+
+ 'fact_10': {
+ 'eq': x**4*f(x)**2 + 2*x**4*f(x)*Derivative(f(x), (x, 2)) + x**4*Derivative(f(x),
+ (x, 2))**2 + 2*x**3*f(x)*Derivative(f(x), x) + 2*x**3*Derivative(f(x),
+ x)*Derivative(f(x), (x, 2)) - 7*x**2*f(x)**2 - 7*x**2*f(x)*Derivative(f(x),
+ (x, 2)) + x**2*Derivative(f(x), x)**2 - 7*x*f(x)*Derivative(f(x), x) + 12*f(x)**2,
+ 'sol': [
+ Eq(f(x), C1*besselj(2, x) + C2*bessely(2, x)),
+ Eq(f(x), C1*besselj(sqrt(3), x) + C2*bessely(sqrt(3), x))
+ ],
+ 'slow': True,
+ },
+
+ 'fact_11': {
+ 'eq': (f(x).diff(x, 2)-exp(f(x)))*(f(x).diff(x, 2)+exp(f(x))),
+ 'sol': [
+ Eq(f(x), log(C1/(cos(C1*sqrt(-1/C1)*(C2 + x)) - 1))),
+ Eq(f(x), log(C1/(cos(C1*sqrt(-1/C1)*(C2 - x)) - 1))),
+ Eq(f(x), log(C1/(1 - cos(C1*sqrt(-1/C1)*(C2 + x))))),
+ Eq(f(x), log(C1/(1 - cos(C1*sqrt(-1/C1)*(C2 - x)))))
+ ],
+ 'dsolve_too_slow': True,
+ },
+
+ #Below examples were added for the issue: https://github.com/sympy/sympy/issues/15889
+ 'fact_12': {
+ 'eq': exp(f(x).diff(x))-f(x)**2,
+ 'sol': [Eq(NonElementaryIntegral(1/log(y**2), (y, f(x))), C1 + x)],
+ 'XFAIL': ['lie_group'] #It shows not implemented error for lie_group.
+ },
+
+ 'fact_13': {
+ 'eq': f(x).diff(x)**2 - f(x)**3,
+ 'sol': [Eq(f(x), 4/(C1**2 - 2*C1*x + x**2))],
+ 'XFAIL': ['lie_group'] #It shows not implemented error for lie_group.
+ },
+
+ 'fact_14': {
+ 'eq': f(x).diff(x)**2 - f(x),
+ 'sol': [Eq(f(x), C1**2/4 - C1*x/2 + x**2/4)]
+ },
+
+ 'fact_15': {
+ 'eq': f(x).diff(x)**2 - f(x)**2,
+ 'sol': [Eq(f(x), C1*exp(x)), Eq(f(x), C1*exp(-x))]
+ },
+
+ 'fact_16': {
+ 'eq': f(x).diff(x)**2 - f(x)**3,
+ 'sol': [Eq(f(x), 4/(C1**2 - 2*C1*x + x**2))],
+ },
+
+ # kamke ode 1.1
+ 'fact_17': {
+ 'eq': f(x).diff(x)-(a4*x**4 + a3*x**3 + a2*x**2 + a1*x + a0)**(-1/2),
+ 'sol': [Eq(f(x), C1 + Integral(1/sqrt(a0 + a1*x + a2*x**2 + a3*x**3 + a4*x**4), x))],
+ 'slow': True
+ },
+
+ # This is from issue: https://github.com/sympy/sympy/issues/9446
+ 'fact_18':{
+ 'eq': Eq(f(2 * x), sin(Derivative(f(x)))),
+ 'sol': [Eq(f(x), C1 + Integral(pi - asin(f(2*x)), x)), Eq(f(x), C1 + Integral(asin(f(2*x)), x))],
+ 'checkodesol_XFAIL':True
+ },
+
+ # This is from issue: https://github.com/sympy/sympy/issues/7093
+ 'fact_19': {
+ 'eq': Derivative(f(x), x)**2 - x**3,
+ 'sol': [Eq(f(x), C1 - 2*x**Rational(5,2)/5), Eq(f(x), C1 + 2*x**Rational(5,2)/5)],
+ },
+
+ 'fact_20': {
+ 'eq': x*f(x).diff(x, 2) - x*f(x),
+ 'sol': [Eq(f(x), C1*exp(-x) + C2*exp(x))],
+ },
+ }
+ }
+
+
+
+@_add_example_keys
+def _get_examples_ode_sol_almost_linear():
+ from sympy.functions.special.error_functions import Ei
+ A = Symbol('A', positive=True)
+ f = Function('f')
+ d = f(x).diff(x)
+
+ return {
+ 'hint': "almost_linear",
+ 'func': f(x),
+ 'examples':{
+ 'almost_lin_01': {
+ 'eq': x**2*f(x)**2*d + f(x)**3 + 1,
+ 'sol': [Eq(f(x), (C1*exp(3/x) - 1)**Rational(1, 3)),
+ Eq(f(x), (-1 - sqrt(3)*I)*(C1*exp(3/x) - 1)**Rational(1, 3)/2),
+ Eq(f(x), (-1 + sqrt(3)*I)*(C1*exp(3/x) - 1)**Rational(1, 3)/2)],
+
+ },
+
+ 'almost_lin_02': {
+ 'eq': x*f(x)*d + 2*x*f(x)**2 + 1,
+ 'sol': [Eq(f(x), -sqrt((C1 - 2*Ei(4*x))*exp(-4*x))), Eq(f(x), sqrt((C1 - 2*Ei(4*x))*exp(-4*x)))]
+ },
+
+ 'almost_lin_03': {
+ 'eq': x*d + x*f(x) + 1,
+ 'sol': [Eq(f(x), (C1 - Ei(x))*exp(-x))]
+ },
+
+ 'almost_lin_04': {
+ 'eq': x*exp(f(x))*d + exp(f(x)) + 3*x,
+ 'sol': [Eq(f(x), log(C1/x - x*Rational(3, 2)))],
+ },
+
+ 'almost_lin_05': {
+ 'eq': x + A*(x + diff(f(x), x) + f(x)) + diff(f(x), x) + f(x) + 2,
+ 'sol': [Eq(f(x), (C1 + Piecewise(
+ (x, Eq(A + 1, 0)), ((-A*x + A - x - 1)*exp(x)/(A + 1), True)))*exp(-x))],
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_liouville():
+ n = Symbol('n')
+ _y = Dummy('y')
+ return {
+ 'hint': "Liouville",
+ 'func': f(x),
+ 'examples':{
+ 'liouville_01': {
+ 'eq': diff(f(x), x)/x + diff(f(x), x, x)/2 - diff(f(x), x)**2/2,
+ 'sol': [Eq(f(x), log(x/(C1 + C2*x)))],
+
+ },
+
+ 'liouville_02': {
+ 'eq': diff(x*exp(-f(x)), x, x),
+ 'sol': [Eq(f(x), log(x/(C1 + C2*x)))]
+ },
+
+ 'liouville_03': {
+ 'eq': ((diff(f(x), x)/x + diff(f(x), x, x)/2 - diff(f(x), x)**2/2)*exp(-f(x))/exp(f(x))).expand(),
+ 'sol': [Eq(f(x), log(x/(C1 + C2*x)))]
+ },
+
+ 'liouville_04': {
+ 'eq': diff(f(x), x, x) + 1/f(x)*(diff(f(x), x))**2 + 1/x*diff(f(x), x),
+ 'sol': [Eq(f(x), -sqrt(C1 + C2*log(x))), Eq(f(x), sqrt(C1 + C2*log(x)))],
+ },
+
+ 'liouville_05': {
+ 'eq': x*diff(f(x), x, x) + x/f(x)*diff(f(x), x)**2 + x*diff(f(x), x),
+ 'sol': [Eq(f(x), -sqrt(C1 + C2*exp(-x))), Eq(f(x), sqrt(C1 + C2*exp(-x)))],
+ },
+
+ 'liouville_06': {
+ 'eq': Eq((x*exp(f(x))).diff(x, x), 0),
+ 'sol': [Eq(f(x), log(C1 + C2/x))],
+ },
+
+ 'liouville_07': {
+ 'eq': (diff(f(x), x)/x + diff(f(x), x, x)/2 - diff(f(x), x)**2/2)*exp(-f(x))/exp(f(x)),
+ 'sol': [Eq(f(x), log(x/(C1 + C2*x)))],
+ },
+
+ 'liouville_08': {
+ 'eq': x**2*diff(f(x),x) + (n*f(x) + f(x)**2)*diff(f(x),x)**2 + diff(f(x), (x, 2)),
+ 'sol': [Eq(C1 + C2*lowergamma(Rational(1,3), x**3/3) + NonElementaryIntegral(exp(_y**3/3)*exp(_y**2*n/2), (_y, f(x))), 0)],
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_nth_algebraic():
+ M, m, r, t = symbols('M m r t')
+ phi = Function('phi')
+ k = Symbol('k')
+ # This one needs a substitution f' = g.
+ # 'algeb_12': {
+ # 'eq': -exp(x) + (x*Derivative(f(x), (x, 2)) + Derivative(f(x), x))/x,
+ # 'sol': [Eq(f(x), C1 + C2*log(x) + exp(x) - Ei(x))],
+ # },
+ return {
+ 'hint': "nth_algebraic",
+ 'func': f(x),
+ 'examples':{
+ 'algeb_01': {
+ 'eq': f(x) * f(x).diff(x) * f(x).diff(x, x) * (f(x) - 1) * (f(x).diff(x) - x),
+ 'sol': [Eq(f(x), C1 + x**2/2), Eq(f(x), C1 + C2*x)]
+ },
+
+ 'algeb_02': {
+ 'eq': f(x) * f(x).diff(x) * f(x).diff(x, x) * (f(x) - 1),
+ 'sol': [Eq(f(x), C1 + C2*x)]
+ },
+
+ 'algeb_03': {
+ 'eq': f(x) * f(x).diff(x) * f(x).diff(x, x),
+ 'sol': [Eq(f(x), C1 + C2*x)]
+ },
+
+ 'algeb_04': {
+ 'eq': Eq(-M * phi(t).diff(t),
+ Rational(3, 2) * m * r**2 * phi(t).diff(t) * phi(t).diff(t,t)),
+ 'sol': [Eq(phi(t), C1), Eq(phi(t), C1 + C2*t - M*t**2/(3*m*r**2))],
+ 'func': phi(t)
+ },
+
+ 'algeb_05': {
+ 'eq': (1 - sin(f(x))) * f(x).diff(x),
+ 'sol': [Eq(f(x), C1)],
+ 'XFAIL': ['separable'] #It raised exception.
+ },
+
+ 'algeb_06': {
+ 'eq': (diff(f(x)) - x)*(diff(f(x)) + x),
+ 'sol': [Eq(f(x), C1 - x**2/2), Eq(f(x), C1 + x**2/2)]
+ },
+
+ 'algeb_07': {
+ 'eq': Eq(Derivative(f(x), x), Derivative(g(x), x)),
+ 'sol': [Eq(f(x), C1 + g(x))],
+ },
+
+ 'algeb_08': {
+ 'eq': f(x).diff(x) - C1, #this example is from issue 15999
+ 'sol': [Eq(f(x), C1*x + C2)],
+ },
+
+ 'algeb_09': {
+ 'eq': f(x)*f(x).diff(x),
+ 'sol': [Eq(f(x), C1)],
+ },
+
+ 'algeb_10': {
+ 'eq': (diff(f(x)) - x)*(diff(f(x)) + x),
+ 'sol': [Eq(f(x), C1 - x**2/2), Eq(f(x), C1 + x**2/2)],
+ },
+
+ 'algeb_11': {
+ 'eq': f(x) + f(x)*f(x).diff(x),
+ 'sol': [Eq(f(x), 0), Eq(f(x), C1 - x)],
+ 'XFAIL': ['separable', '1st_exact', '1st_linear', 'Bernoulli', '1st_homogeneous_coeff_best',
+ '1st_homogeneous_coeff_subs_indep_div_dep', '1st_homogeneous_coeff_subs_dep_div_indep',
+ 'lie_group', 'nth_linear_constant_coeff_undetermined_coefficients',
+ 'nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients',
+ 'nth_linear_constant_coeff_variation_of_parameters',
+ 'nth_linear_euler_eq_nonhomogeneous_variation_of_parameters']
+ #nth_linear_constant_coeff_undetermined_coefficients raises exception rest all of them misses a solution.
+ },
+
+ 'algeb_12': {
+ 'eq': Derivative(x*f(x), x, x, x),
+ 'sol': [Eq(f(x), (C1 + C2*x + C3*x**2) / x)],
+ 'XFAIL': ['nth_algebraic'] # It passes only when prep=False is set in dsolve.
+ },
+
+ 'algeb_13': {
+ 'eq': Eq(Derivative(x*Derivative(f(x), x), x)/x, exp(x)),
+ 'sol': [Eq(f(x), C1 + C2*log(x) + exp(x) - Ei(x))],
+ 'XFAIL': ['nth_algebraic'] # It passes only when prep=False is set in dsolve.
+ },
+
+ # These are simple tests from the old ode module example 14-18
+ 'algeb_14': {
+ 'eq': Eq(f(x).diff(x), 0),
+ 'sol': [Eq(f(x), C1)],
+ },
+
+ 'algeb_15': {
+ 'eq': Eq(3*f(x).diff(x) - 5, 0),
+ 'sol': [Eq(f(x), C1 + x*Rational(5, 3))],
+ },
+
+ 'algeb_16': {
+ 'eq': Eq(3*f(x).diff(x), 5),
+ 'sol': [Eq(f(x), C1 + x*Rational(5, 3))],
+ },
+
+ # Type: 2nd order, constant coefficients (two complex roots)
+ 'algeb_17': {
+ 'eq': Eq(3*f(x).diff(x) - 1, 0),
+ 'sol': [Eq(f(x), C1 + x/3)],
+ },
+
+ 'algeb_18': {
+ 'eq': Eq(x*f(x).diff(x) - 1, 0),
+ 'sol': [Eq(f(x), C1 + log(x))],
+ },
+
+ # https://github.com/sympy/sympy/issues/6989
+ 'algeb_19': {
+ 'eq': f(x).diff(x) - x*exp(-k*x),
+ 'sol': [Eq(f(x), C1 + Piecewise(((-k*x - 1)*exp(-k*x)/k**2, Ne(k**2, 0)),(x**2/2, True)))],
+ },
+
+ 'algeb_20': {
+ 'eq': -f(x).diff(x) + x*exp(-k*x),
+ 'sol': [Eq(f(x), C1 + Piecewise(((-k*x - 1)*exp(-k*x)/k**2, Ne(k**2, 0)),(x**2/2, True)))],
+ },
+
+ # https://github.com/sympy/sympy/issues/10867
+ 'algeb_21': {
+ 'eq': Eq(g(x).diff(x).diff(x), (x-2)**2 + (x-3)**3),
+ 'sol': [Eq(g(x), C1 + C2*x + x**5/20 - 2*x**4/3 + 23*x**3/6 - 23*x**2/2)],
+ 'func': g(x),
+ },
+
+ # https://github.com/sympy/sympy/issues/13691
+ 'algeb_22': {
+ 'eq': f(x).diff(x) - C1*g(x).diff(x),
+ 'sol': [Eq(f(x), C2 + C1*g(x))],
+ 'func': f(x),
+ },
+
+ # https://github.com/sympy/sympy/issues/4838
+ 'algeb_23': {
+ 'eq': f(x).diff(x) - 3*C1 - 3*x**2,
+ 'sol': [Eq(f(x), C2 + 3*C1*x + x**3)],
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_nth_order_reducible():
+ return {
+ 'hint': "nth_order_reducible",
+ 'func': f(x),
+ 'examples':{
+ 'reducible_01': {
+ 'eq': Eq(x*Derivative(f(x), x)**2 + Derivative(f(x), x, 2), 0),
+ 'sol': [Eq(f(x),C1 - sqrt(-1/C2)*log(-C2*sqrt(-1/C2) + x) +
+ sqrt(-1/C2)*log(C2*sqrt(-1/C2) + x))],
+ 'slow': True,
+ },
+
+ 'reducible_02': {
+ 'eq': -exp(x) + (x*Derivative(f(x), (x, 2)) + Derivative(f(x), x))/x,
+ 'sol': [Eq(f(x), C1 + C2*log(x) + exp(x) - Ei(x))],
+ 'slow': True,
+ },
+
+ 'reducible_03': {
+ 'eq': Eq(sqrt(2) * f(x).diff(x,x,x) + f(x).diff(x), 0),
+ 'sol': [Eq(f(x), C1 + C2*sin(2**Rational(3, 4)*x/2) + C3*cos(2**Rational(3, 4)*x/2))],
+ 'slow': True,
+ },
+
+ 'reducible_04': {
+ 'eq': f(x).diff(x, 2) + 2*f(x).diff(x),
+ 'sol': [Eq(f(x), C1 + C2*exp(-2*x))],
+ },
+
+ 'reducible_05': {
+ 'eq': f(x).diff(x, 3) + f(x).diff(x, 2) - 6*f(x).diff(x),
+ 'sol': [Eq(f(x), C1 + C2*exp(-3*x) + C3*exp(2*x))],
+ 'slow': True,
+ },
+
+ 'reducible_06': {
+ 'eq': f(x).diff(x, 4) - f(x).diff(x, 3) - 4*f(x).diff(x, 2) + \
+ 4*f(x).diff(x),
+ 'sol': [Eq(f(x), C1 + C2*exp(-2*x) + C3*exp(x) + C4*exp(2*x))],
+ 'slow': True,
+ },
+
+ 'reducible_07': {
+ 'eq': f(x).diff(x, 4) + 3*f(x).diff(x, 3),
+ 'sol': [Eq(f(x), C1 + C2*x + C3*x**2 + C4*exp(-3*x))],
+ 'slow': True,
+ },
+
+ 'reducible_08': {
+ 'eq': f(x).diff(x, 4) - 2*f(x).diff(x, 2),
+ 'sol': [Eq(f(x), C1 + C2*x + C3*exp(-sqrt(2)*x) + C4*exp(sqrt(2)*x))],
+ 'slow': True,
+ },
+
+ 'reducible_09': {
+ 'eq': f(x).diff(x, 4) + 4*f(x).diff(x, 2),
+ 'sol': [Eq(f(x), C1 + C2*x + C3*sin(2*x) + C4*cos(2*x))],
+ 'slow': True,
+ },
+
+ 'reducible_10': {
+ 'eq': f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x),
+ 'sol': [Eq(f(x), C1 + C2*x*sin(x) + C2*cos(x) - C3*x*cos(x) + C3*sin(x) + C4*sin(x) + C5*cos(x))],
+ 'slow': True,
+ },
+
+ 'reducible_11': {
+ 'eq': f(x).diff(x, 2) - f(x).diff(x)**3,
+ 'sol': [Eq(f(x), C1 - sqrt(2)*sqrt(-1/(C2 + x))*(C2 + x)),
+ Eq(f(x), C1 + sqrt(2)*sqrt(-1/(C2 + x))*(C2 + x))],
+ 'slow': True,
+ },
+
+ # Needs to be a way to know how to combine derivatives in the expression
+ 'reducible_12': {
+ 'eq': Derivative(x*f(x), x, x, x) + Derivative(f(x), x, x, x),
+ 'sol': [Eq(f(x), C1 + C3/Mul(2, (x**2 + 2*x + 1), evaluate=False) +
+ x*(C2 + C3/Mul(2, (x**2 + 2*x + 1), evaluate=False)))], # 2-arg Mul!
+ 'slow': True,
+ },
+ }
+ }
+
+
+
+@_add_example_keys
+def _get_examples_ode_sol_nth_linear_undetermined_coefficients():
+ # examples 3-27 below are from Ordinary Differential Equations,
+ # Tenenbaum and Pollard, pg. 231
+ g = exp(-x)
+ f2 = f(x).diff(x, 2)
+ c = 3*f(x).diff(x, 3) + 5*f2 + f(x).diff(x) - f(x) - x
+ t = symbols("t")
+ u = symbols("u",cls=Function)
+ R, L, C, E_0, alpha = symbols("R L C E_0 alpha",positive=True)
+ omega = Symbol('omega')
+ return {
+ 'hint': "nth_linear_constant_coeff_undetermined_coefficients",
+ 'func': f(x),
+ 'examples':{
+ 'undet_01': {
+ 'eq': c - x*g,
+ 'sol': [Eq(f(x), C3*exp(x/3) - x + (C1 + x*(C2 - x**2/24 - 3*x/32))*exp(-x) - 1)],
+ 'slow': True,
+ },
+
+ 'undet_02': {
+ 'eq': c - g,
+ 'sol': [Eq(f(x), C3*exp(x/3) - x + (C1 + x*(C2 - x/8))*exp(-x) - 1)],
+ 'slow': True,
+ },
+
+ 'undet_03': {
+ 'eq': f2 + 3*f(x).diff(x) + 2*f(x) - 4,
+ 'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + 2)],
+ 'slow': True,
+ },
+
+ 'undet_04': {
+ 'eq': f2 + 3*f(x).diff(x) + 2*f(x) - 12*exp(x),
+ 'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + 2*exp(x))],
+ 'slow': True,
+ },
+
+ 'undet_05': {
+ 'eq': f2 + 3*f(x).diff(x) + 2*f(x) - exp(I*x),
+ 'sol': [Eq(f(x), (S(3)/10 + I/10)*(C1*exp(-2*x) + C2*exp(-x) - I*exp(I*x)))],
+ 'slow': True,
+ },
+
+ 'undet_06': {
+ 'eq': f2 + 3*f(x).diff(x) + 2*f(x) - sin(x),
+ 'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + sin(x)/10 - 3*cos(x)/10)],
+ 'slow': True,
+ },
+
+ 'undet_07': {
+ 'eq': f2 + 3*f(x).diff(x) + 2*f(x) - cos(x),
+ 'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + 3*sin(x)/10 + cos(x)/10)],
+ 'slow': True,
+ },
+
+ 'undet_08': {
+ 'eq': f2 + 3*f(x).diff(x) + 2*f(x) - (8 + 6*exp(x) + 2*sin(x)),
+ 'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + exp(x) + sin(x)/5 - 3*cos(x)/5 + 4)],
+ 'slow': True,
+ },
+
+ 'undet_09': {
+ 'eq': f2 + f(x).diff(x) + f(x) - x**2,
+ 'sol': [Eq(f(x), -2*x + x**2 + (C1*sin(x*sqrt(3)/2) + C2*cos(x*sqrt(3)/2))*exp(-x/2))],
+ 'slow': True,
+ },
+
+ 'undet_10': {
+ 'eq': f2 - 2*f(x).diff(x) - 8*f(x) - 9*x*exp(x) - 10*exp(-x),
+ 'sol': [Eq(f(x), -x*exp(x) - 2*exp(-x) + C1*exp(-2*x) + C2*exp(4*x))],
+ 'slow': True,
+ },
+
+ 'undet_11': {
+ 'eq': f2 - 3*f(x).diff(x) - 2*exp(2*x)*sin(x),
+ 'sol': [Eq(f(x), C1 + C2*exp(3*x) - 3*exp(2*x)*sin(x)/5 - exp(2*x)*cos(x)/5)],
+ 'slow': True,
+ },
+
+ 'undet_12': {
+ 'eq': f(x).diff(x, 4) - 2*f2 + f(x) - x + sin(x),
+ 'sol': [Eq(f(x), x - sin(x)/4 + (C1 + C2*x)*exp(-x) + (C3 + C4*x)*exp(x))],
+ 'slow': True,
+ },
+
+ 'undet_13': {
+ 'eq': f2 + f(x).diff(x) - x**2 - 2*x,
+ 'sol': [Eq(f(x), C1 + x**3/3 + C2*exp(-x))],
+ 'slow': True,
+ },
+
+ 'undet_14': {
+ 'eq': f2 + f(x).diff(x) - x - sin(2*x),
+ 'sol': [Eq(f(x), C1 - x - sin(2*x)/5 - cos(2*x)/10 + x**2/2 + C2*exp(-x))],
+ 'slow': True,
+ },
+
+ 'undet_15': {
+ 'eq': f2 + f(x) - 4*x*sin(x),
+ 'sol': [Eq(f(x), (C1 - x**2)*cos(x) + (C2 + x)*sin(x))],
+ 'slow': True,
+ },
+
+ 'undet_16': {
+ 'eq': f2 + 4*f(x) - x*sin(2*x),
+ 'sol': [Eq(f(x), (C1 - x**2/8)*cos(2*x) + (C2 + x/16)*sin(2*x))],
+ 'slow': True,
+ },
+
+ 'undet_17': {
+ 'eq': f2 + 2*f(x).diff(x) + f(x) - x**2*exp(-x),
+ 'sol': [Eq(f(x), (C1 + x*(C2 + x**3/12))*exp(-x))],
+ 'slow': True,
+ },
+
+ 'undet_18': {
+ 'eq': f(x).diff(x, 3) + 3*f2 + 3*f(x).diff(x) + f(x) - 2*exp(-x) + \
+ x**2*exp(-x),
+ 'sol': [Eq(f(x), (C1 + x*(C2 + x*(C3 - x**3/60 + x/3)))*exp(-x))],
+ 'slow': True,
+ },
+
+ 'undet_19': {
+ 'eq': f2 + 3*f(x).diff(x) + 2*f(x) - exp(-2*x) - x**2,
+ 'sol': [Eq(f(x), C2*exp(-x) + x**2/2 - x*Rational(3,2) + (C1 - x)*exp(-2*x) + Rational(7,4))],
+ 'slow': True,
+ },
+
+ 'undet_20': {
+ 'eq': f2 - 3*f(x).diff(x) + 2*f(x) - x*exp(-x),
+ 'sol': [Eq(f(x), C1*exp(x) + C2*exp(2*x) + (6*x + 5)*exp(-x)/36)],
+ 'slow': True,
+ },
+
+ 'undet_21': {
+ 'eq': f2 + f(x).diff(x) - 6*f(x) - x - exp(2*x),
+ 'sol': [Eq(f(x), Rational(-1, 36) - x/6 + C2*exp(-3*x) + (C1 + x/5)*exp(2*x))],
+ 'slow': True,
+ },
+
+ 'undet_22': {
+ 'eq': f2 + f(x) - sin(x) - exp(-x),
+ 'sol': [Eq(f(x), C2*sin(x) + (C1 - x/2)*cos(x) + exp(-x)/2)],
+ 'slow': True,
+ },
+
+ 'undet_23': {
+ 'eq': f(x).diff(x, 3) - 3*f2 + 3*f(x).diff(x) - f(x) - exp(x),
+ 'sol': [Eq(f(x), (C1 + x*(C2 + x*(C3 + x/6)))*exp(x))],
+ 'slow': True,
+ },
+
+ 'undet_24': {
+ 'eq': f2 + f(x) - S.Half - cos(2*x)/2,
+ 'sol': [Eq(f(x), S.Half - cos(2*x)/6 + C1*sin(x) + C2*cos(x))],
+ 'slow': True,
+ },
+
+ 'undet_25': {
+ 'eq': f(x).diff(x, 3) - f(x).diff(x) - exp(2*x)*(S.Half - cos(2*x)/2),
+ 'sol': [Eq(f(x), C1 + C2*exp(-x) + C3*exp(x) + (-21*sin(2*x) + 27*cos(2*x) + 130)*exp(2*x)/1560)],
+ 'slow': True,
+ },
+
+ #Note: 'undet_26' is referred in 'undet_37'
+ 'undet_26': {
+ 'eq': (f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x) - 2*x -
+ sin(x) - cos(x)),
+ 'sol': [Eq(f(x), C1 + x**2 + (C2 + x*(C3 - x/8))*sin(x) + (C4 + x*(C5 + x/8))*cos(x))],
+ 'slow': True,
+ },
+
+ 'undet_27': {
+ 'eq': f2 + f(x) - cos(x)/2 + cos(3*x)/2,
+ 'sol': [Eq(f(x), cos(3*x)/16 + C2*cos(x) + (C1 + x/4)*sin(x))],
+ 'slow': True,
+ },
+
+ 'undet_28': {
+ 'eq': f(x).diff(x) - 1,
+ 'sol': [Eq(f(x), C1 + x)],
+ 'slow': True,
+ },
+
+ # https://github.com/sympy/sympy/issues/19358
+ 'undet_29': {
+ 'eq': f2 + f(x).diff(x) + exp(x-C1),
+ 'sol': [Eq(f(x), C2 + C3*exp(-x) - exp(-C1 + x)/2)],
+ 'slow': True,
+ },
+
+ # https://github.com/sympy/sympy/issues/18408
+ 'undet_30': {
+ 'eq': f(x).diff(x, 3) - f(x).diff(x) - sinh(x),
+ 'sol': [Eq(f(x), C1 + C2*exp(-x) + C3*exp(x) + x*sinh(x)/2)],
+ },
+
+ 'undet_31': {
+ 'eq': f(x).diff(x, 2) - 49*f(x) - sinh(3*x),
+ 'sol': [Eq(f(x), C1*exp(-7*x) + C2*exp(7*x) - sinh(3*x)/40)],
+ },
+
+ 'undet_32': {
+ 'eq': f(x).diff(x, 3) - f(x).diff(x) - sinh(x) - exp(x),
+ 'sol': [Eq(f(x), C1 + C3*exp(-x) + x*sinh(x)/2 + (C2 + x/2)*exp(x))],
+ },
+
+ # https://github.com/sympy/sympy/issues/5096
+ 'undet_33': {
+ 'eq': f(x).diff(x, x) + f(x) - x*sin(x - 2),
+ 'sol': [Eq(f(x), C1*sin(x) + C2*cos(x) - x**2*cos(x - 2)/4 + x*sin(x - 2)/4)],
+ },
+
+ 'undet_34': {
+ 'eq': f(x).diff(x, 2) + f(x) - x**4*sin(x-1),
+ 'sol': [ Eq(f(x), C1*sin(x) + C2*cos(x) - x**5*cos(x - 1)/10 + x**4*sin(x - 1)/4 + x**3*cos(x - 1)/2 - 3*x**2*sin(x - 1)/4 - 3*x*cos(x - 1)/4)],
+ },
+
+ 'undet_35': {
+ 'eq': f(x).diff(x, 2) - f(x) - exp(x - 1),
+ 'sol': [Eq(f(x), C2*exp(-x) + (C1 + x*exp(-1)/2)*exp(x))],
+ },
+
+ 'undet_36': {
+ 'eq': f(x).diff(x, 2)+f(x)-(sin(x-2)+1),
+ 'sol': [Eq(f(x), C1*sin(x) + C2*cos(x) - x*cos(x - 2)/2 + 1)],
+ },
+
+ # Equivalent to example_name 'undet_26'.
+ # This previously failed because the algorithm for undetermined coefficients
+ # didn't know to multiply exp(I*x) by sufficient x because it is linearly
+ # dependent on sin(x) and cos(x).
+ 'undet_37': {
+ 'eq': f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x) - 2*x - exp(I*x),
+ 'sol': [Eq(f(x), C1 + x**2*(I*exp(I*x)/8 + 1) + (C2 + C3*x)*sin(x) + (C4 + C5*x)*cos(x))],
+ },
+
+ # https://github.com/sympy/sympy/issues/12623
+ 'undet_38': {
+ 'eq': Eq( u(t).diff(t,t) + R /L*u(t).diff(t) + 1/(L*C)*u(t), alpha),
+ 'sol': [Eq(u(t), C*L*alpha + C2*exp(-t*(R + sqrt(C*R**2 - 4*L)/sqrt(C))/(2*L))
+ + C1*exp(t*(-R + sqrt(C*R**2 - 4*L)/sqrt(C))/(2*L)))],
+ 'func': u(t)
+ },
+
+ 'undet_39': {
+ 'eq': Eq( L*C*u(t).diff(t,t) + R*C*u(t).diff(t) + u(t), E_0*exp(I*omega*t) ),
+ 'sol': [Eq(u(t), C2*exp(-t*(R + sqrt(C*R**2 - 4*L)/sqrt(C))/(2*L))
+ + C1*exp(t*(-R + sqrt(C*R**2 - 4*L)/sqrt(C))/(2*L))
+ - E_0*exp(I*omega*t)/(C*L*omega**2 - I*C*R*omega - 1))],
+ 'func': u(t),
+ },
+
+ # https://github.com/sympy/sympy/issues/6879
+ 'undet_40': {
+ 'eq': Eq(Derivative(f(x), x, 2) - 2*Derivative(f(x), x) + f(x), sin(x)),
+ 'sol': [Eq(f(x), (C1 + C2*x)*exp(x) + cos(x)/2)],
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_separable():
+ # test_separable1-5 are from Ordinary Differential Equations, Tenenbaum and
+ # Pollard, pg. 55
+ t,a = symbols('a,t')
+ m = 96
+ g = 9.8
+ k = .2
+ f1 = g * m
+ v = Function('v')
+ return {
+ 'hint': "separable",
+ 'func': f(x),
+ 'examples':{
+ 'separable_01': {
+ 'eq': f(x).diff(x) - f(x),
+ 'sol': [Eq(f(x), C1*exp(x))],
+ },
+
+ 'separable_02': {
+ 'eq': x*f(x).diff(x) - f(x),
+ 'sol': [Eq(f(x), C1*x)],
+ },
+
+ 'separable_03': {
+ 'eq': f(x).diff(x) + sin(x),
+ 'sol': [Eq(f(x), C1 + cos(x))],
+ },
+
+ 'separable_04': {
+ 'eq': f(x)**2 + 1 - (x**2 + 1)*f(x).diff(x),
+ 'sol': [Eq(f(x), tan(C1 + atan(x)))],
+ },
+
+ 'separable_05': {
+ 'eq': f(x).diff(x)/tan(x) - f(x) - 2,
+ 'sol': [Eq(f(x), C1/cos(x) - 2)],
+ },
+
+ 'separable_06': {
+ 'eq': f(x).diff(x) * (1 - sin(f(x))) - 1,
+ 'sol': [Eq(-x + f(x) + cos(f(x)), C1)],
+ },
+
+ 'separable_07': {
+ 'eq': f(x)*x**2*f(x).diff(x) - f(x)**3 - 2*x**2*f(x).diff(x),
+ 'sol': [Eq(f(x), (-x - sqrt(x*(4*C1*x + x - 4)))/(C1*x - 1)/2),
+ Eq(f(x), (-x + sqrt(x*(4*C1*x + x - 4)))/(C1*x - 1)/2)],
+ 'slow': True,
+ },
+
+ 'separable_08': {
+ 'eq': f(x)**2 - 1 - (2*f(x) + x*f(x))*f(x).diff(x),
+ 'sol': [Eq(f(x), -sqrt(C1*x**2 + 4*C1*x + 4*C1 + 1)),
+ Eq(f(x), sqrt(C1*x**2 + 4*C1*x + 4*C1 + 1))],
+ 'slow': True,
+ },
+
+ 'separable_09': {
+ 'eq': x*log(x)*f(x).diff(x) + sqrt(1 + f(x)**2),
+ 'sol': [Eq(f(x), sinh(C1 - log(log(x))))], #One more solution is f(x)=I
+ 'slow': True,
+ 'checkodesol_XFAIL': True,
+ },
+
+ 'separable_10': {
+ 'eq': exp(x + 1)*tan(f(x)) + cos(f(x))*f(x).diff(x),
+ 'sol': [Eq(E*exp(x) + log(cos(f(x)) - 1)/2 - log(cos(f(x)) + 1)/2 + cos(f(x)), C1)],
+ 'slow': True,
+ },
+
+ 'separable_11': {
+ 'eq': (x*cos(f(x)) + x**2*sin(f(x))*f(x).diff(x) - a**2*sin(f(x))*f(x).diff(x)),
+ 'sol': [
+ Eq(f(x), -acos(C1*sqrt(-a**2 + x**2)) + 2*pi),
+ Eq(f(x), acos(C1*sqrt(-a**2 + x**2)))
+ ],
+ 'slow': True,
+ },
+
+ 'separable_12': {
+ 'eq': f(x).diff(x) - f(x)*tan(x),
+ 'sol': [Eq(f(x), C1/cos(x))],
+ },
+
+ 'separable_13': {
+ 'eq': (x - 1)*cos(f(x))*f(x).diff(x) - 2*x*sin(f(x)),
+ 'sol': [
+ Eq(f(x), pi - asin(C1*(x**2 - 2*x + 1)*exp(2*x))),
+ Eq(f(x), asin(C1*(x**2 - 2*x + 1)*exp(2*x)))
+ ],
+ },
+
+ 'separable_14': {
+ 'eq': f(x).diff(x) - f(x)*log(f(x))/tan(x),
+ 'sol': [Eq(f(x), exp(C1*sin(x)))],
+ },
+
+ 'separable_15': {
+ 'eq': x*f(x).diff(x) + (1 + f(x)**2)*atan(f(x)),
+ 'sol': [Eq(f(x), tan(C1/x))], #Two more solutions are f(x)=0 and f(x)=I
+ 'slow': True,
+ 'checkodesol_XFAIL': True,
+ },
+
+ 'separable_16': {
+ 'eq': f(x).diff(x) + x*(f(x) + 1),
+ 'sol': [Eq(f(x), -1 + C1*exp(-x**2/2))],
+ },
+
+ 'separable_17': {
+ 'eq': exp(f(x)**2)*(x**2 + 2*x + 1) + (x*f(x) + f(x))*f(x).diff(x),
+ 'sol': [
+ Eq(f(x), -sqrt(log(1/(C1 + x**2 + 2*x)))),
+ Eq(f(x), sqrt(log(1/(C1 + x**2 + 2*x))))
+ ],
+ },
+
+ 'separable_18': {
+ 'eq': f(x).diff(x) + f(x),
+ 'sol': [Eq(f(x), C1*exp(-x))],
+ },
+
+ 'separable_19': {
+ 'eq': sin(x)*cos(2*f(x)) + cos(x)*sin(2*f(x))*f(x).diff(x),
+ 'sol': [Eq(f(x), pi - acos(C1/cos(x)**2)/2), Eq(f(x), acos(C1/cos(x)**2)/2)],
+ },
+
+ 'separable_20': {
+ 'eq': (1 - x)*f(x).diff(x) - x*(f(x) + 1),
+ 'sol': [Eq(f(x), (C1*exp(-x) - x + 1)/(x - 1))],
+ },
+
+ 'separable_21': {
+ 'eq': f(x)*diff(f(x), x) + x - 3*x*f(x)**2,
+ 'sol': [Eq(f(x), -sqrt(3)*sqrt(C1*exp(3*x**2) + 1)/3),
+ Eq(f(x), sqrt(3)*sqrt(C1*exp(3*x**2) + 1)/3)],
+ },
+
+ 'separable_22': {
+ 'eq': f(x).diff(x) - exp(x + f(x)),
+ 'sol': [Eq(f(x), log(-1/(C1 + exp(x))))],
+ 'XFAIL': ['lie_group'] #It shows 'NoneType' object is not subscriptable for lie_group.
+ },
+
+ # https://github.com/sympy/sympy/issues/7081
+ 'separable_23': {
+ 'eq': x*(f(x).diff(x)) + 1 - f(x)**2,
+ 'sol': [Eq(f(x), (-C1 - x**2)/(-C1 + x**2))],
+ },
+
+ # https://github.com/sympy/sympy/issues/10379
+ 'separable_24': {
+ 'eq': f(t).diff(t)-(1-51.05*y*f(t)),
+ 'sol': [Eq(f(t), (0.019588638589618023*exp(y*(C1 - 51.049999999999997*t)) + 0.019588638589618023)/y)],
+ 'func': f(t),
+ },
+
+ # https://github.com/sympy/sympy/issues/15999
+ 'separable_25': {
+ 'eq': f(x).diff(x) - C1*f(x),
+ 'sol': [Eq(f(x), C2*exp(C1*x))],
+ },
+
+ 'separable_26': {
+ 'eq': f1 - k * (v(t) ** 2) - m * Derivative(v(t)),
+ 'sol': [Eq(v(t), -68.585712797928991/tanh(C1 - 0.14288690166235204*t))],
+ 'func': v(t),
+ 'checkodesol_XFAIL': True,
+ },
+
+ #https://github.com/sympy/sympy/issues/22155
+ 'separable_27': {
+ 'eq': f(x).diff(x) - exp(f(x) - x),
+ 'sol': [Eq(f(x), log(-exp(x)/(C1*exp(x) - 1)))],
+ }
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_1st_exact():
+ # Type: Exact differential equation, p(x,f) + q(x,f)*f' == 0,
+ # where dp/df == dq/dx
+ '''
+ Example 7 is an exact equation that fails under the exact engine. It is caught
+ by first order homogeneous albeit with a much contorted solution. The
+ exact engine fails because of a poorly simplified integral of q(0,y)dy,
+ where q is the function multiplying f'. The solutions should be
+ Eq(sqrt(x**2+f(x)**2)**3+y**3, C1). The equation below is
+ equivalent, but it is so complex that checkodesol fails, and takes a long
+ time to do so.
+ '''
+ return {
+ 'hint': "1st_exact",
+ 'func': f(x),
+ 'examples':{
+ '1st_exact_01': {
+ 'eq': sin(x)*cos(f(x)) + cos(x)*sin(f(x))*f(x).diff(x),
+ 'sol': [Eq(f(x), -acos(C1/cos(x)) + 2*pi), Eq(f(x), acos(C1/cos(x)))],
+ 'slow': True,
+ },
+
+ '1st_exact_02': {
+ 'eq': (2*x*f(x) + 1)/f(x) + (f(x) - x)/f(x)**2*f(x).diff(x),
+ 'sol': [Eq(f(x), exp(C1 - x**2 + LambertW(-x*exp(-C1 + x**2))))],
+ 'XFAIL': ['lie_group'], #It shows dsolve raises an exception: List index out of range for lie_group
+ 'slow': True,
+ 'checkodesol_XFAIL':True
+ },
+
+ '1st_exact_03': {
+ 'eq': 2*x + f(x)*cos(x) + (2*f(x) + sin(x) - sin(f(x)))*f(x).diff(x),
+ 'sol': [Eq(f(x)*sin(x) + cos(f(x)) + x**2 + f(x)**2, C1)],
+ 'XFAIL': ['lie_group'], #It goes into infinite loop for lie_group.
+ 'slow': True,
+ },
+
+ '1st_exact_04': {
+ 'eq': cos(f(x)) - (x*sin(f(x)) - f(x)**2)*f(x).diff(x),
+ 'sol': [Eq(x*cos(f(x)) + f(x)**3/3, C1)],
+ 'slow': True,
+ },
+
+ '1st_exact_05': {
+ 'eq': 2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x),
+ 'sol': [Eq(x**2*f(x) + f(x)**3/3, C1)],
+ 'slow': True,
+ 'simplify_flag':False
+ },
+
+ # This was from issue: https://github.com/sympy/sympy/issues/11290
+ '1st_exact_06': {
+ 'eq': cos(f(x)) - (x*sin(f(x)) - f(x)**2)*f(x).diff(x),
+ 'sol': [Eq(x*cos(f(x)) + f(x)**3/3, C1)],
+ 'simplify_flag':False
+ },
+
+ '1st_exact_07': {
+ 'eq': x*sqrt(x**2 + f(x)**2) - (x**2*f(x)/(f(x) - sqrt(x**2 + f(x)**2)))*f(x).diff(x),
+ 'sol': [Eq(log(x),
+ C1 - 9*sqrt(1 + f(x)**2/x**2)*asinh(f(x)/x)/(-27*f(x)/x +
+ 27*sqrt(1 + f(x)**2/x**2)) - 9*sqrt(1 + f(x)**2/x**2)*
+ log(1 - sqrt(1 + f(x)**2/x**2)*f(x)/x + 2*f(x)**2/x**2)/
+ (-27*f(x)/x + 27*sqrt(1 + f(x)**2/x**2)) +
+ 9*asinh(f(x)/x)*f(x)/(x*(-27*f(x)/x + 27*sqrt(1 + f(x)**2/x**2))) +
+ 9*f(x)*log(1 - sqrt(1 + f(x)**2/x**2)*f(x)/x + 2*f(x)**2/x**2)/
+ (x*(-27*f(x)/x + 27*sqrt(1 + f(x)**2/x**2))))],
+ 'slow': True,
+ 'dsolve_too_slow':True
+ },
+
+ # Type: a(x)f'(x)+b(x)*f(x)+c(x)=0
+ '1st_exact_08': {
+ 'eq': Eq(x**2*f(x).diff(x) + 3*x*f(x) - sin(x)/x, 0),
+ 'sol': [Eq(f(x), (C1 - cos(x))/x**3)],
+ },
+
+ # these examples are from test_exact_enhancement
+ '1st_exact_09': {
+ 'eq': f(x)/x**2 + ((f(x)*x - 1)/x)*f(x).diff(x),
+ 'sol': [Eq(f(x), (i*sqrt(C1*x**2 + 1) + 1)/x) for i in (-1, 1)],
+ },
+
+ '1st_exact_10': {
+ 'eq': (x*f(x) - 1) + f(x).diff(x)*(x**2 - x*f(x)),
+ 'sol': [Eq(f(x), x - sqrt(C1 + x**2 - 2*log(x))), Eq(f(x), x + sqrt(C1 + x**2 - 2*log(x)))],
+ },
+
+ '1st_exact_11': {
+ 'eq': (x + 2)*sin(f(x)) + f(x).diff(x)*x*cos(f(x)),
+ 'sol': [Eq(f(x), -asin(C1*exp(-x)/x**2) + pi), Eq(f(x), asin(C1*exp(-x)/x**2))],
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_nth_linear_var_of_parameters():
+ g = exp(-x)
+ f2 = f(x).diff(x, 2)
+ c = 3*f(x).diff(x, 3) + 5*f2 + f(x).diff(x) - f(x) - x
+ return {
+ 'hint': "nth_linear_constant_coeff_variation_of_parameters",
+ 'func': f(x),
+ 'examples':{
+ 'var_of_parameters_01': {
+ 'eq': c - x*g,
+ 'sol': [Eq(f(x), C3*exp(x/3) - x + (C1 + x*(C2 - x**2/24 - 3*x/32))*exp(-x) - 1)],
+ 'slow': True,
+ },
+
+ 'var_of_parameters_02': {
+ 'eq': c - g,
+ 'sol': [Eq(f(x), C3*exp(x/3) - x + (C1 + x*(C2 - x/8))*exp(-x) - 1)],
+ 'slow': True,
+ },
+
+ 'var_of_parameters_03': {
+ 'eq': f(x).diff(x) - 1,
+ 'sol': [Eq(f(x), C1 + x)],
+ 'slow': True,
+ },
+
+ 'var_of_parameters_04': {
+ 'eq': f2 + 3*f(x).diff(x) + 2*f(x) - 4,
+ 'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + 2)],
+ 'slow': True,
+ },
+
+ 'var_of_parameters_05': {
+ 'eq': f2 + 3*f(x).diff(x) + 2*f(x) - 12*exp(x),
+ 'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + 2*exp(x))],
+ 'slow': True,
+ },
+
+ 'var_of_parameters_06': {
+ 'eq': f2 - 2*f(x).diff(x) - 8*f(x) - 9*x*exp(x) - 10*exp(-x),
+ 'sol': [Eq(f(x), -x*exp(x) - 2*exp(-x) + C1*exp(-2*x) + C2*exp(4*x))],
+ 'slow': True,
+ },
+
+ 'var_of_parameters_07': {
+ 'eq': f2 + 2*f(x).diff(x) + f(x) - x**2*exp(-x),
+ 'sol': [Eq(f(x), (C1 + x*(C2 + x**3/12))*exp(-x))],
+ 'slow': True,
+ },
+
+ 'var_of_parameters_08': {
+ 'eq': f2 - 3*f(x).diff(x) + 2*f(x) - x*exp(-x),
+ 'sol': [Eq(f(x), C1*exp(x) + C2*exp(2*x) + (6*x + 5)*exp(-x)/36)],
+ 'slow': True,
+ },
+
+ 'var_of_parameters_09': {
+ 'eq': f(x).diff(x, 3) - 3*f2 + 3*f(x).diff(x) - f(x) - exp(x),
+ 'sol': [Eq(f(x), (C1 + x*(C2 + x*(C3 + x/6)))*exp(x))],
+ 'slow': True,
+ },
+
+ 'var_of_parameters_10': {
+ 'eq': f2 + 2*f(x).diff(x) + f(x) - exp(-x)/x,
+ 'sol': [Eq(f(x), (C1 + x*(C2 + log(x)))*exp(-x))],
+ 'slow': True,
+ },
+
+ 'var_of_parameters_11': {
+ 'eq': f2 + f(x) - 1/sin(x)*1/cos(x),
+ 'sol': [Eq(f(x), (C1 + log(sin(x) - 1)/2 - log(sin(x) + 1)/2
+ )*cos(x) + (C2 + log(cos(x) - 1)/2 - log(cos(x) + 1)/2)*sin(x))],
+ 'slow': True,
+ },
+
+ 'var_of_parameters_12': {
+ 'eq': f(x).diff(x, 4) - 1/x,
+ 'sol': [Eq(f(x), C1 + C2*x + C3*x**2 + x**3*(C4 + log(x)/6))],
+ 'slow': True,
+ },
+
+ # These were from issue: https://github.com/sympy/sympy/issues/15996
+ 'var_of_parameters_13': {
+ 'eq': f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x) - 2*x - exp(I*x),
+ 'sol': [Eq(f(x), C1 + x**2 + (C2 + x*(C3 - x/8 + 3*exp(I*x)/2 + 3*exp(-I*x)/2) + 5*exp(2*I*x)/16 + 2*I*exp(I*x) - 2*I*exp(-I*x))*sin(x) + (C4 + x*(C5 + I*x/8 + 3*I*exp(I*x)/2 - 3*I*exp(-I*x)/2)
+ + 5*I*exp(2*I*x)/16 - 2*exp(I*x) - 2*exp(-I*x))*cos(x) - I*exp(I*x))],
+ },
+
+ 'var_of_parameters_14': {
+ 'eq': f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x) - exp(I*x),
+ 'sol': [Eq(f(x), C1 + (C2 + x*(C3 - x/8) + 5*exp(2*I*x)/16)*sin(x) + (C4 + x*(C5 + I*x/8) + 5*I*exp(2*I*x)/16)*cos(x) - I*exp(I*x))],
+ },
+
+ # https://github.com/sympy/sympy/issues/14395
+ 'var_of_parameters_15': {
+ 'eq': Derivative(f(x), x, x) + 9*f(x) - sec(x),
+ 'sol': [Eq(f(x), (C1 - x/3 + sin(2*x)/3)*sin(3*x) + (C2 + log(cos(x))
+ - 2*log(cos(x)**2)/3 + 2*cos(x)**2/3)*cos(3*x))],
+ 'slow': True,
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_2nd_linear_bessel():
+ return {
+ 'hint': "2nd_linear_bessel",
+ 'func': f(x),
+ 'examples':{
+ '2nd_lin_bessel_01': {
+ 'eq': x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (x**2 - 4)*f(x),
+ 'sol': [Eq(f(x), C1*besselj(2, x) + C2*bessely(2, x))],
+ },
+
+ '2nd_lin_bessel_02': {
+ 'eq': x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (x**2 +25)*f(x),
+ 'sol': [Eq(f(x), C1*besselj(5*I, x) + C2*bessely(5*I, x))],
+ },
+
+ '2nd_lin_bessel_03': {
+ 'eq': x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (x**2)*f(x),
+ 'sol': [Eq(f(x), C1*besselj(0, x) + C2*bessely(0, x))],
+ },
+
+ '2nd_lin_bessel_04': {
+ 'eq': x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (81*x**2 -S(1)/9)*f(x),
+ 'sol': [Eq(f(x), C1*besselj(S(1)/3, 9*x) + C2*bessely(S(1)/3, 9*x))],
+ },
+
+ '2nd_lin_bessel_05': {
+ 'eq': x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (x**4 - 4)*f(x),
+ 'sol': [Eq(f(x), C1*besselj(1, x**2/2) + C2*bessely(1, x**2/2))],
+ },
+
+ '2nd_lin_bessel_06': {
+ 'eq': x**2*(f(x).diff(x, 2)) + 2*x*(f(x).diff(x)) + (x**4 - 4)*f(x),
+ 'sol': [Eq(f(x), (C1*besselj(sqrt(17)/4, x**2/2) + C2*bessely(sqrt(17)/4, x**2/2))/sqrt(x))],
+ },
+
+ '2nd_lin_bessel_07': {
+ 'eq': x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (x**2 - S(1)/4)*f(x),
+ 'sol': [Eq(f(x), C1*besselj(S(1)/2, x) + C2*bessely(S(1)/2, x))],
+ },
+
+ '2nd_lin_bessel_08': {
+ 'eq': x**2*(f(x).diff(x, 2)) - 3*x*(f(x).diff(x)) + (4*x + 4)*f(x),
+ 'sol': [Eq(f(x), x**2*(C1*besselj(0, 4*sqrt(x)) + C2*bessely(0, 4*sqrt(x))))],
+ },
+
+ '2nd_lin_bessel_09': {
+ 'eq': x*(f(x).diff(x, 2)) - f(x).diff(x) + 4*x**3*f(x),
+ 'sol': [Eq(f(x), x*(C1*besselj(S(1)/2, x**2) + C2*bessely(S(1)/2, x**2)))],
+ },
+
+ '2nd_lin_bessel_10': {
+ 'eq': (x-2)**2*(f(x).diff(x, 2)) - (x-2)*f(x).diff(x) + 4*(x-2)**2*f(x),
+ 'sol': [Eq(f(x), (x - 2)*(C1*besselj(1, 2*x - 4) + C2*bessely(1, 2*x - 4)))],
+ },
+
+ # https://github.com/sympy/sympy/issues/4414
+ '2nd_lin_bessel_11': {
+ 'eq': f(x).diff(x, x) + 2/x*f(x).diff(x) + f(x),
+ 'sol': [Eq(f(x), (C1*besselj(S(1)/2, x) + C2*bessely(S(1)/2, x))/sqrt(x))],
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_2nd_2F1_hypergeometric():
+ return {
+ 'hint': "2nd_hypergeometric",
+ 'func': f(x),
+ 'examples':{
+ '2nd_2F1_hyper_01': {
+ 'eq': x*(x-1)*f(x).diff(x, 2) + (S(3)/2 -2*x)*f(x).diff(x) + 2*f(x),
+ 'sol': [Eq(f(x), C1*x**(S(5)/2)*hyper((S(3)/2, S(1)/2), (S(7)/2,), x) + C2*hyper((-1, -2), (-S(3)/2,), x))],
+ },
+
+ '2nd_2F1_hyper_02': {
+ 'eq': x*(x-1)*f(x).diff(x, 2) + (S(7)/2*x)*f(x).diff(x) + f(x),
+ 'sol': [Eq(f(x), (C1*(1 - x)**(S(5)/2)*hyper((S(1)/2, 2), (S(7)/2,), 1 - x) +
+ C2*hyper((-S(1)/2, -2), (-S(3)/2,), 1 - x))/(x - 1)**(S(5)/2))],
+ },
+
+ '2nd_2F1_hyper_03': {
+ 'eq': x*(x-1)*f(x).diff(x, 2) + (S(3)+ S(7)/2*x)*f(x).diff(x) + f(x),
+ 'sol': [Eq(f(x), (C1*(1 - x)**(S(11)/2)*hyper((S(1)/2, 2), (S(13)/2,), 1 - x) +
+ C2*hyper((-S(7)/2, -5), (-S(9)/2,), 1 - x))/(x - 1)**(S(11)/2))],
+ },
+
+ '2nd_2F1_hyper_04': {
+ 'eq': -x**(S(5)/7)*(-416*x**(S(9)/7)/9 - 2385*x**(S(5)/7)/49 + S(298)*x/3)*f(x)/(196*(-x**(S(6)/7) +
+ x)**2*(x**(S(6)/7) + x)**2) + Derivative(f(x), (x, 2)),
+ 'sol': [Eq(f(x), x**(S(45)/98)*(C1*x**(S(4)/49)*hyper((S(1)/3, -S(1)/2), (S(9)/7,), x**(S(2)/7)) +
+ C2*hyper((S(1)/21, -S(11)/14), (S(5)/7,), x**(S(2)/7)))/(x**(S(2)/7) - 1)**(S(19)/84))],
+ 'checkodesol_XFAIL':True,
+ },
+ }
+ }
+
+@_add_example_keys
+def _get_examples_ode_sol_2nd_nonlinear_autonomous_conserved():
+ return {
+ 'hint': "2nd_nonlinear_autonomous_conserved",
+ 'func': f(x),
+ 'examples': {
+ '2nd_nonlinear_autonomous_conserved_01': {
+ 'eq': f(x).diff(x, 2) + exp(f(x)) + log(f(x)),
+ 'sol': [
+ Eq(Integral(1/sqrt(C1 - 2*_u*log(_u) + 2*_u - 2*exp(_u)), (_u, f(x))), C2 + x),
+ Eq(Integral(1/sqrt(C1 - 2*_u*log(_u) + 2*_u - 2*exp(_u)), (_u, f(x))), C2 - x)
+ ],
+ 'simplify_flag': False,
+ },
+ '2nd_nonlinear_autonomous_conserved_02': {
+ 'eq': f(x).diff(x, 2) + cbrt(f(x)) + 1/f(x),
+ 'sol': [
+ Eq(sqrt(2)*Integral(1/sqrt(2*C1 - 3*_u**Rational(4, 3) - 4*log(_u)), (_u, f(x))), C2 + x),
+ Eq(sqrt(2)*Integral(1/sqrt(2*C1 - 3*_u**Rational(4, 3) - 4*log(_u)), (_u, f(x))), C2 - x)
+ ],
+ 'simplify_flag': False,
+ },
+ '2nd_nonlinear_autonomous_conserved_03': {
+ 'eq': f(x).diff(x, 2) + sin(f(x)),
+ 'sol': [
+ Eq(Integral(1/sqrt(C1 + 2*cos(_u)), (_u, f(x))), C2 + x),
+ Eq(Integral(1/sqrt(C1 + 2*cos(_u)), (_u, f(x))), C2 - x)
+ ],
+ 'simplify_flag': False,
+ },
+ '2nd_nonlinear_autonomous_conserved_04': {
+ 'eq': f(x).diff(x, 2) + cosh(f(x)),
+ 'sol': [
+ Eq(Integral(1/sqrt(C1 - 2*sinh(_u)), (_u, f(x))), C2 + x),
+ Eq(Integral(1/sqrt(C1 - 2*sinh(_u)), (_u, f(x))), C2 - x)
+ ],
+ 'simplify_flag': False,
+ },
+ '2nd_nonlinear_autonomous_conserved_05': {
+ 'eq': f(x).diff(x, 2) + asin(f(x)),
+ 'sol': [
+ Eq(Integral(1/sqrt(C1 - 2*_u*asin(_u) - 2*sqrt(1 - _u**2)), (_u, f(x))), C2 + x),
+ Eq(Integral(1/sqrt(C1 - 2*_u*asin(_u) - 2*sqrt(1 - _u**2)), (_u, f(x))), C2 - x)
+ ],
+ 'simplify_flag': False,
+ 'XFAIL': ['2nd_nonlinear_autonomous_conserved_Integral']
+ }
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_separable_reduced():
+ df = f(x).diff(x)
+ return {
+ 'hint': "separable_reduced",
+ 'func': f(x),
+ 'examples':{
+ 'separable_reduced_01': {
+ 'eq': x* df + f(x)* (1 / (x**2*f(x) - 1)),
+ 'sol': [Eq(log(x**2*f(x))/3 + log(x**2*f(x) - Rational(3, 2))/6, C1 + log(x))],
+ 'simplify_flag': False,
+ 'XFAIL': ['lie_group'], #It hangs.
+ },
+
+ #Note: 'separable_reduced_02' is referred in 'separable_reduced_11'
+ 'separable_reduced_02': {
+ 'eq': f(x).diff(x) + (f(x) / (x**4*f(x) - x)),
+ 'sol': [Eq(log(x**3*f(x))/4 + log(x**3*f(x) - Rational(4,3))/12, C1 + log(x))],
+ 'simplify_flag': False,
+ 'checkodesol_XFAIL':True, #It hangs for this.
+ },
+
+ 'separable_reduced_03': {
+ 'eq': x*df + f(x)*(x**2*f(x)),
+ 'sol': [Eq(log(x**2*f(x))/2 - log(x**2*f(x) - 2)/2, C1 + log(x))],
+ 'simplify_flag': False,
+ },
+
+ 'separable_reduced_04': {
+ 'eq': Eq(f(x).diff(x) + f(x)/x * (1 + (x**(S(2)/3)*f(x))**2), 0),
+ 'sol': [Eq(-3*log(x**(S(2)/3)*f(x)) + 3*log(3*x**(S(4)/3)*f(x)**2 + 1)/2, C1 + log(x))],
+ 'simplify_flag': False,
+ },
+
+ 'separable_reduced_05': {
+ 'eq': Eq(f(x).diff(x) + f(x)/x * (1 + (x*f(x))**2), 0),
+ 'sol': [Eq(f(x), -sqrt(2)*sqrt(1/(C1 + log(x)))/(2*x)),\
+ Eq(f(x), sqrt(2)*sqrt(1/(C1 + log(x)))/(2*x))],
+ },
+
+ 'separable_reduced_06': {
+ 'eq': Eq(f(x).diff(x) + (x**4*f(x)**2 + x**2*f(x))*f(x)/(x*(x**6*f(x)**3 + x**4*f(x)**2)), 0),
+ 'sol': [Eq(f(x), C1 + 1/(2*x**2))],
+ },
+
+ 'separable_reduced_07': {
+ 'eq': Eq(f(x).diff(x) + (f(x)**2)*f(x)/(x), 0),
+ 'sol': [
+ Eq(f(x), -sqrt(2)*sqrt(1/(C1 + log(x)))/2),
+ Eq(f(x), sqrt(2)*sqrt(1/(C1 + log(x)))/2)
+ ],
+ },
+
+ 'separable_reduced_08': {
+ 'eq': Eq(f(x).diff(x) + (f(x)+3)*f(x)/(x*(f(x)+2)), 0),
+ 'sol': [Eq(-log(f(x) + 3)/3 - 2*log(f(x))/3, C1 + log(x))],
+ 'simplify_flag': False,
+ 'XFAIL': ['lie_group'], #It hangs.
+ },
+
+ 'separable_reduced_09': {
+ 'eq': Eq(f(x).diff(x) + (f(x)+3)*f(x)/x, 0),
+ 'sol': [Eq(f(x), 3/(C1*x**3 - 1))],
+ },
+
+ 'separable_reduced_10': {
+ 'eq': Eq(f(x).diff(x) + (f(x)**2+f(x))*f(x)/(x), 0),
+ 'sol': [Eq(- log(x) - log(f(x) + 1) + log(f(x)) + 1/f(x), C1)],
+ 'XFAIL': ['lie_group'],#No algorithms are implemented to solve equation -C1 + x*(_y + 1)*exp(-1/_y)/_y
+
+ },
+
+ # Equivalent to example_name 'separable_reduced_02'. Only difference is testing with simplify=True
+ 'separable_reduced_11': {
+ 'eq': f(x).diff(x) + (f(x) / (x**4*f(x) - x)),
+ 'sol': [Eq(f(x), -sqrt(2)*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)/6
+- sqrt(2)*sqrt(-3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
++ 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 4/x**6
+- 4*sqrt(2)/(x**9*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)))/6 + 1/(3*x**3)),
+Eq(f(x), -sqrt(2)*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)/6
++ sqrt(2)*sqrt(-3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
++ 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 4/x**6
+- 4*sqrt(2)/(x**9*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)))/6 + 1/(3*x**3)),
+Eq(f(x), sqrt(2)*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)/6
+- sqrt(2)*sqrt(-3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
++ 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
++ 4/x**6 + 4*sqrt(2)/(x**9*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)))/6 + 1/(3*x**3)),
+Eq(f(x), sqrt(2)*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)/6
++ sqrt(2)*sqrt(-3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1)
++ x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 4/x**6 + 4*sqrt(2)/(x**9*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1))
+- exp(12*C1)/x**6)**Rational(1,3) - 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)))/6 + 1/(3*x**3))],
+ 'checkodesol_XFAIL':True, #It hangs for this.
+ 'slow': True,
+ },
+
+ #These were from issue: https://github.com/sympy/sympy/issues/6247
+ 'separable_reduced_12': {
+ 'eq': x**2*f(x)**2 + x*Derivative(f(x), x),
+ 'sol': [Eq(f(x), 2*C1/(C1*x**2 - 1))],
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_lie_group():
+ a, b, c = symbols("a b c")
+ return {
+ 'hint': "lie_group",
+ 'func': f(x),
+ 'examples':{
+ #Example 1-4 and 19-20 were from issue: https://github.com/sympy/sympy/issues/17322
+ 'lie_group_01': {
+ 'eq': x*f(x).diff(x)*(f(x)+4) + (f(x)**2) -2*f(x)-2*x,
+ 'sol': [],
+ 'dsolve_too_slow': True,
+ 'checkodesol_too_slow': True,
+ },
+
+ 'lie_group_02': {
+ 'eq': x*f(x).diff(x)*(f(x)+4) + (f(x)**2) -2*f(x)-2*x,
+ 'sol': [],
+ 'dsolve_too_slow': True,
+ },
+
+ 'lie_group_03': {
+ 'eq': Eq(x**7*Derivative(f(x), x) + 5*x**3*f(x)**2 - (2*x**2 + 2)*f(x)**3, 0),
+ 'sol': [],
+ 'dsolve_too_slow': True,
+ },
+
+ 'lie_group_04': {
+ 'eq': f(x).diff(x) - (f(x) - x*log(x))**2/x**2 + log(x),
+ 'sol': [],
+ 'XFAIL': ['lie_group'],
+ },
+
+ 'lie_group_05': {
+ 'eq': f(x).diff(x)**2,
+ 'sol': [Eq(f(x), C1)],
+ 'XFAIL': ['factorable'], #It raises Not Implemented error
+ },
+
+ 'lie_group_06': {
+ 'eq': Eq(f(x).diff(x), x**2*f(x)),
+ 'sol': [Eq(f(x), C1*exp(x**3)**Rational(1, 3))],
+ },
+
+ 'lie_group_07': {
+ 'eq': f(x).diff(x) + a*f(x) - c*exp(b*x),
+ 'sol': [Eq(f(x), Piecewise(((-C1*(a + b) + c*exp(x*(a + b)))*exp(-a*x)/(a + b),\
+ Ne(a, -b)), ((-C1 + c*x)*exp(-a*x), True)))],
+ },
+
+ 'lie_group_08': {
+ 'eq': f(x).diff(x) + 2*x*f(x) - x*exp(-x**2),
+ 'sol': [Eq(f(x), (C1 + x**2/2)*exp(-x**2))],
+ },
+
+ 'lie_group_09': {
+ 'eq': (1 + 2*x)*(f(x).diff(x)) + 2 - 4*exp(-f(x)),
+ 'sol': [Eq(f(x), log(C1/(2*x + 1) + 2))],
+ },
+
+ 'lie_group_10': {
+ 'eq': x**2*(f(x).diff(x)) - f(x) + x**2*exp(x - (1/x)),
+ 'sol': [Eq(f(x), (C1 - exp(x))*exp(-1/x))],
+ 'XFAIL': ['factorable'], #It raises Recursion Error (maixmum depth exceeded)
+ },
+
+ 'lie_group_11': {
+ 'eq': x**2*f(x)**2 + x*Derivative(f(x), x),
+ 'sol': [Eq(f(x), 2/(C1 + x**2))],
+ },
+
+ 'lie_group_12': {
+ 'eq': diff(f(x),x) + 2*x*f(x) - x*exp(-x**2),
+ 'sol': [Eq(f(x), exp(-x**2)*(C1 + x**2/2))],
+ },
+
+ 'lie_group_13': {
+ 'eq': diff(f(x),x) + f(x)*cos(x) - exp(2*x),
+ 'sol': [Eq(f(x), exp(-sin(x))*(C1 + Integral(exp(2*x)*exp(sin(x)), x)))],
+ },
+
+ 'lie_group_14': {
+ 'eq': diff(f(x),x) + f(x)*cos(x) - sin(2*x)/2,
+ 'sol': [Eq(f(x), C1*exp(-sin(x)) + sin(x) - 1)],
+ },
+
+ 'lie_group_15': {
+ 'eq': x*diff(f(x),x) + f(x) - x*sin(x),
+ 'sol': [Eq(f(x), (C1 - x*cos(x) + sin(x))/x)],
+ },
+
+ 'lie_group_16': {
+ 'eq': x*diff(f(x),x) - f(x) - x/log(x),
+ 'sol': [Eq(f(x), x*(C1 + log(log(x))))],
+ },
+
+ 'lie_group_17': {
+ 'eq': (f(x).diff(x)-f(x)) * (f(x).diff(x)+f(x)),
+ 'sol': [Eq(f(x), C1*exp(x)), Eq(f(x), C1*exp(-x))],
+ },
+
+ 'lie_group_18': {
+ 'eq': f(x).diff(x) * (f(x).diff(x) - f(x)),
+ 'sol': [Eq(f(x), C1*exp(x)), Eq(f(x), C1)],
+ },
+
+ 'lie_group_19': {
+ 'eq': (f(x).diff(x)-f(x)) * (f(x).diff(x)+f(x)),
+ 'sol': [Eq(f(x), C1*exp(-x)), Eq(f(x), C1*exp(x))],
+ },
+
+ 'lie_group_20': {
+ 'eq': f(x).diff(x)*(f(x).diff(x)+f(x)),
+ 'sol': [Eq(f(x), C1), Eq(f(x), C1*exp(-x))],
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_2nd_linear_airy():
+ return {
+ 'hint': "2nd_linear_airy",
+ 'func': f(x),
+ 'examples':{
+ '2nd_lin_airy_01': {
+ 'eq': f(x).diff(x, 2) - x*f(x),
+ 'sol': [Eq(f(x), C1*airyai(x) + C2*airybi(x))],
+ },
+
+ '2nd_lin_airy_02': {
+ 'eq': f(x).diff(x, 2) + 2*x*f(x),
+ 'sol': [Eq(f(x), C1*airyai(-2**(S(1)/3)*x) + C2*airybi(-2**(S(1)/3)*x))],
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_nth_linear_constant_coeff_homogeneous():
+ # From Exercise 20, in Ordinary Differential Equations,
+ # Tenenbaum and Pollard, pg. 220
+ a = Symbol('a', positive=True)
+ k = Symbol('k', real=True)
+ r1, r2, r3, r4, r5 = [rootof(x**5 + 11*x - 2, n) for n in range(5)]
+ r6, r7, r8, r9, r10 = [rootof(x**5 - 3*x + 1, n) for n in range(5)]
+ r11, r12, r13, r14, r15 = [rootof(x**5 - 100*x**3 + 1000*x + 1, n) for n in range(5)]
+ r16, r17, r18, r19, r20 = [rootof(x**5 - x**4 + 10, n) for n in range(5)]
+ r21, r22, r23, r24, r25 = [rootof(x**5 - x + 1, n) for n in range(5)]
+ E = exp(1)
+ return {
+ 'hint': "nth_linear_constant_coeff_homogeneous",
+ 'func': f(x),
+ 'examples':{
+ 'lin_const_coeff_hom_01': {
+ 'eq': f(x).diff(x, 2) + 2*f(x).diff(x),
+ 'sol': [Eq(f(x), C1 + C2*exp(-2*x))],
+ },
+
+ 'lin_const_coeff_hom_02': {
+ 'eq': f(x).diff(x, 2) - 3*f(x).diff(x) + 2*f(x),
+ 'sol': [Eq(f(x), (C1 + C2*exp(x))*exp(x))],
+ },
+
+ 'lin_const_coeff_hom_03': {
+ 'eq': f(x).diff(x, 2) - f(x),
+ 'sol': [Eq(f(x), C1*exp(-x) + C2*exp(x))],
+ },
+
+ 'lin_const_coeff_hom_04': {
+ 'eq': f(x).diff(x, 3) + f(x).diff(x, 2) - 6*f(x).diff(x),
+ 'sol': [Eq(f(x), C1 + C2*exp(-3*x) + C3*exp(2*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_05': {
+ 'eq': 6*f(x).diff(x, 2) - 11*f(x).diff(x) + 4*f(x),
+ 'sol': [Eq(f(x), C1*exp(x/2) + C2*exp(x*Rational(4, 3)))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_06': {
+ 'eq': Eq(f(x).diff(x, 2) + 2*f(x).diff(x) - f(x), 0),
+ 'sol': [Eq(f(x), C1*exp(x*(-1 + sqrt(2))) + C2*exp(-x*(sqrt(2) + 1)))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_07': {
+ 'eq': diff(f(x), x, 3) + diff(f(x), x, 2) - 10*diff(f(x), x) - 6*f(x),
+ 'sol': [Eq(f(x), C1*exp(3*x) + C3*exp(-x*(2 + sqrt(2))) + C2*exp(x*(-2 + sqrt(2))))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_08': {
+ 'eq': f(x).diff(x, 4) - f(x).diff(x, 3) - 4*f(x).diff(x, 2) + \
+ 4*f(x).diff(x),
+ 'sol': [Eq(f(x), C1 + C2*exp(-2*x) + C3*exp(x) + C4*exp(2*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_09': {
+ 'eq': f(x).diff(x, 4) + 4*f(x).diff(x, 3) + f(x).diff(x, 2) - \
+ 4*f(x).diff(x) - 2*f(x),
+ 'sol': [Eq(f(x), C3*exp(-x) + C4*exp(x) + (C1*exp(-sqrt(2)*x) + C2*exp(sqrt(2)*x))*exp(-2*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_10': {
+ 'eq': f(x).diff(x, 4) - a**2*f(x),
+ 'sol': [Eq(f(x), C1*exp(-sqrt(a)*x) + C2*exp(sqrt(a)*x) + C3*sin(sqrt(a)*x) + C4*cos(sqrt(a)*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_11': {
+ 'eq': f(x).diff(x, 2) - 2*k*f(x).diff(x) - 2*f(x),
+ 'sol': [Eq(f(x), C1*exp(x*(k - sqrt(k**2 + 2))) + C2*exp(x*(k + sqrt(k**2 + 2))))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_12': {
+ 'eq': f(x).diff(x, 2) + 4*k*f(x).diff(x) - 12*k**2*f(x),
+ 'sol': [Eq(f(x), C1*exp(-6*k*x) + C2*exp(2*k*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_13': {
+ 'eq': f(x).diff(x, 4),
+ 'sol': [Eq(f(x), C1 + C2*x + C3*x**2 + C4*x**3)],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_14': {
+ 'eq': f(x).diff(x, 2) + 4*f(x).diff(x) + 4*f(x),
+ 'sol': [Eq(f(x), (C1 + C2*x)*exp(-2*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_15': {
+ 'eq': 3*f(x).diff(x, 3) + 5*f(x).diff(x, 2) + f(x).diff(x) - f(x),
+ 'sol': [Eq(f(x), (C1 + C2*x)*exp(-x) + C3*exp(x/3))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_16': {
+ 'eq': f(x).diff(x, 3) - 6*f(x).diff(x, 2) + 12*f(x).diff(x) - 8*f(x),
+ 'sol': [Eq(f(x), (C1 + x*(C2 + C3*x))*exp(2*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_17': {
+ 'eq': f(x).diff(x, 2) - 2*a*f(x).diff(x) + a**2*f(x),
+ 'sol': [Eq(f(x), (C1 + C2*x)*exp(a*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_18': {
+ 'eq': f(x).diff(x, 4) + 3*f(x).diff(x, 3),
+ 'sol': [Eq(f(x), C1 + C2*x + C3*x**2 + C4*exp(-3*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_19': {
+ 'eq': f(x).diff(x, 4) - 2*f(x).diff(x, 2),
+ 'sol': [Eq(f(x), C1 + C2*x + C3*exp(-sqrt(2)*x) + C4*exp(sqrt(2)*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_20': {
+ 'eq': f(x).diff(x, 4) + 2*f(x).diff(x, 3) - 11*f(x).diff(x, 2) - \
+ 12*f(x).diff(x) + 36*f(x),
+ 'sol': [Eq(f(x), (C1 + C2*x)*exp(-3*x) + (C3 + C4*x)*exp(2*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_21': {
+ 'eq': 36*f(x).diff(x, 4) - 37*f(x).diff(x, 2) + 4*f(x).diff(x) + 5*f(x),
+ 'sol': [Eq(f(x), C1*exp(-x) + C2*exp(-x/3) + C3*exp(x/2) + C4*exp(x*Rational(5, 6)))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_22': {
+ 'eq': f(x).diff(x, 4) - 8*f(x).diff(x, 2) + 16*f(x),
+ 'sol': [Eq(f(x), (C1 + C2*x)*exp(-2*x) + (C3 + C4*x)*exp(2*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_23': {
+ 'eq': f(x).diff(x, 2) - 2*f(x).diff(x) + 5*f(x),
+ 'sol': [Eq(f(x), (C1*sin(2*x) + C2*cos(2*x))*exp(x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_24': {
+ 'eq': f(x).diff(x, 2) - f(x).diff(x) + f(x),
+ 'sol': [Eq(f(x), (C1*sin(x*sqrt(3)/2) + C2*cos(x*sqrt(3)/2))*exp(x/2))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_25': {
+ 'eq': f(x).diff(x, 4) + 5*f(x).diff(x, 2) + 6*f(x),
+ 'sol': [Eq(f(x),
+ C1*sin(sqrt(2)*x) + C2*sin(sqrt(3)*x) + C3*cos(sqrt(2)*x) + C4*cos(sqrt(3)*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_26': {
+ 'eq': f(x).diff(x, 2) - 4*f(x).diff(x) + 20*f(x),
+ 'sol': [Eq(f(x), (C1*sin(4*x) + C2*cos(4*x))*exp(2*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_27': {
+ 'eq': f(x).diff(x, 4) + 4*f(x).diff(x, 2) + 4*f(x),
+ 'sol': [Eq(f(x), (C1 + C2*x)*sin(x*sqrt(2)) + (C3 + C4*x)*cos(x*sqrt(2)))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_28': {
+ 'eq': f(x).diff(x, 3) + 8*f(x),
+ 'sol': [Eq(f(x), (C1*sin(x*sqrt(3)) + C2*cos(x*sqrt(3)))*exp(x) + C3*exp(-2*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_29': {
+ 'eq': f(x).diff(x, 4) + 4*f(x).diff(x, 2),
+ 'sol': [Eq(f(x), C1 + C2*x + C3*sin(2*x) + C4*cos(2*x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_30': {
+ 'eq': f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x),
+ 'sol': [Eq(f(x), C1 + (C2 + C3*x)*sin(x) + (C4 + C5*x)*cos(x))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_31': {
+ 'eq': f(x).diff(x, 4) + f(x).diff(x, 2) + f(x),
+ 'sol': [Eq(f(x), (C1*sin(sqrt(3)*x/2) + C2*cos(sqrt(3)*x/2))*exp(-x/2)
+ + (C3*sin(sqrt(3)*x/2) + C4*cos(sqrt(3)*x/2))*exp(x/2))],
+ 'slow': True,
+ },
+
+ 'lin_const_coeff_hom_32': {
+ 'eq': f(x).diff(x, 4) + 4*f(x).diff(x, 2) + f(x),
+ 'sol': [Eq(f(x), C1*sin(x*sqrt(-sqrt(3) + 2)) + C2*sin(x*sqrt(sqrt(3) + 2))
+ + C3*cos(x*sqrt(-sqrt(3) + 2)) + C4*cos(x*sqrt(sqrt(3) + 2)))],
+ 'slow': True,
+ },
+
+ # One real root, two complex conjugate pairs
+ 'lin_const_coeff_hom_33': {
+ 'eq': f(x).diff(x, 5) + 11*f(x).diff(x) - 2*f(x),
+ 'sol': [Eq(f(x),
+ C5*exp(r1*x) + exp(re(r2)*x) * (C1*sin(im(r2)*x) + C2*cos(im(r2)*x))
+ + exp(re(r4)*x) * (C3*sin(im(r4)*x) + C4*cos(im(r4)*x)))],
+ 'checkodesol_XFAIL':True, #It Hangs
+ },
+
+ # Three real roots, one complex conjugate pair
+ 'lin_const_coeff_hom_34': {
+ 'eq': f(x).diff(x,5) - 3*f(x).diff(x) + f(x),
+ 'sol': [Eq(f(x),
+ C3*exp(r6*x) + C4*exp(r7*x) + C5*exp(r8*x)
+ + exp(re(r9)*x) * (C1*sin(im(r9)*x) + C2*cos(im(r9)*x)))],
+ 'checkodesol_XFAIL':True, #It Hangs
+ },
+
+ # Five distinct real roots
+ 'lin_const_coeff_hom_35': {
+ 'eq': f(x).diff(x,5) - 100*f(x).diff(x,3) + 1000*f(x).diff(x) + f(x),
+ 'sol': [Eq(f(x), C1*exp(r11*x) + C2*exp(r12*x) + C3*exp(r13*x) + C4*exp(r14*x) + C5*exp(r15*x))],
+ 'checkodesol_XFAIL':True, #It Hangs
+ },
+
+ # Rational root and unsolvable quintic
+ 'lin_const_coeff_hom_36': {
+ 'eq': f(x).diff(x, 6) - 6*f(x).diff(x, 5) + 5*f(x).diff(x, 4) + 10*f(x).diff(x) - 50 * f(x),
+ 'sol': [Eq(f(x),
+ C5*exp(5*x)
+ + C6*exp(x*r16)
+ + exp(re(r17)*x) * (C1*sin(im(r17)*x) + C2*cos(im(r17)*x))
+ + exp(re(r19)*x) * (C3*sin(im(r19)*x) + C4*cos(im(r19)*x)))],
+ 'checkodesol_XFAIL':True, #It Hangs
+ },
+
+ # Five double roots (this is (x**5 - x + 1)**2)
+ 'lin_const_coeff_hom_37': {
+ 'eq': f(x).diff(x, 10) - 2*f(x).diff(x, 6) + 2*f(x).diff(x, 5)
+ + f(x).diff(x, 2) - 2*f(x).diff(x, 1) + f(x),
+ 'sol': [Eq(f(x), (C1 + C2*x)*exp(x*r21) + (-((C3 + C4*x)*sin(x*im(r22)))
+ + (C5 + C6*x)*cos(x*im(r22)))*exp(x*re(r22)) + (-((C7 + C8*x)*sin(x*im(r24)))
+ + (C10*x + C9)*cos(x*im(r24)))*exp(x*re(r24)))],
+ 'checkodesol_XFAIL':True, #It Hangs
+ },
+
+ 'lin_const_coeff_hom_38': {
+ 'eq': Eq(sqrt(2) * f(x).diff(x,x,x) + f(x).diff(x), 0),
+ 'sol': [Eq(f(x), C1 + C2*sin(2**Rational(3, 4)*x/2) + C3*cos(2**Rational(3, 4)*x/2))],
+ },
+
+ 'lin_const_coeff_hom_39': {
+ 'eq': Eq(E * f(x).diff(x,x,x) + f(x).diff(x), 0),
+ 'sol': [Eq(f(x), C1 + C2*sin(x/sqrt(E)) + C3*cos(x/sqrt(E)))],
+ },
+
+ 'lin_const_coeff_hom_40': {
+ 'eq': Eq(pi * f(x).diff(x,x,x) + f(x).diff(x), 0),
+ 'sol': [Eq(f(x), C1 + C2*sin(x/sqrt(pi)) + C3*cos(x/sqrt(pi)))],
+ },
+
+ 'lin_const_coeff_hom_41': {
+ 'eq': Eq(I * f(x).diff(x,x,x) + f(x).diff(x), 0),
+ 'sol': [Eq(f(x), C1 + C2*exp(-sqrt(I)*x) + C3*exp(sqrt(I)*x))],
+ },
+
+ 'lin_const_coeff_hom_42': {
+ 'eq': f(x).diff(x, x) + y*f(x),
+ 'sol': [Eq(f(x), C1*exp(-x*sqrt(-y)) + C2*exp(x*sqrt(-y)))],
+ },
+
+ 'lin_const_coeff_hom_43': {
+ 'eq': Eq(9*f(x).diff(x, x) + f(x), 0),
+ 'sol': [Eq(f(x), C1*sin(x/3) + C2*cos(x/3))],
+ },
+
+ 'lin_const_coeff_hom_44': {
+ 'eq': Eq(9*f(x).diff(x, x), f(x)),
+ 'sol': [Eq(f(x), C1*exp(-x/3) + C2*exp(x/3))],
+ },
+
+ 'lin_const_coeff_hom_45': {
+ 'eq': Eq(f(x).diff(x, x) - 3*diff(f(x), x) + 2*f(x), 0),
+ 'sol': [Eq(f(x), (C1 + C2*exp(x))*exp(x))],
+ },
+
+ 'lin_const_coeff_hom_46': {
+ 'eq': Eq(f(x).diff(x, x) - 4*diff(f(x), x) + 4*f(x), 0),
+ 'sol': [Eq(f(x), (C1 + C2*x)*exp(2*x))],
+ },
+
+ # Type: 2nd order, constant coefficients (two real equal roots)
+ 'lin_const_coeff_hom_47': {
+ 'eq': Eq(f(x).diff(x, x) + 2*diff(f(x), x) + 3*f(x), 0),
+ 'sol': [Eq(f(x), (C1*sin(x*sqrt(2)) + C2*cos(x*sqrt(2)))*exp(-x))],
+ },
+
+ #These were from issue: https://github.com/sympy/sympy/issues/6247
+ 'lin_const_coeff_hom_48': {
+ 'eq': f(x).diff(x, x) + 4*f(x),
+ 'sol': [Eq(f(x), C1*sin(2*x) + C2*cos(2*x))],
+ },
+ }
+ }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_1st_homogeneous_coeff_subs_dep_div_indep():
+ return {
+ 'hint': "1st_homogeneous_coeff_subs_dep_div_indep",
+ 'func': f(x),
+ 'examples':{
+ 'dep_div_indep_01': {
+ 'eq': f(x)/x*cos(f(x)/x) - (x/f(x)*sin(f(x)/x) + cos(f(x)/x))*f(x).diff(x),
+ 'sol': [Eq(log(x), C1 - log(f(x)*sin(f(x)/x)/x))],
+ 'slow': True
+ },
+
+ #indep_div_dep actually has a simpler solution for example 2 but it runs too slow.
+ 'dep_div_indep_02': {
+ 'eq': x*f(x).diff(x) - f(x) - x*sin(f(x)/x),
+ 'sol': [Eq(log(x), log(C1) + log(cos(f(x)/x) - 1)/2 - log(cos(f(x)/x) + 1)/2)],
+ 'simplify_flag':False,
+ },
+
+ 'dep_div_indep_03': {
+ 'eq': x*exp(f(x)/x) - f(x)*sin(f(x)/x) + x*sin(f(x)/x)*f(x).diff(x),
+ 'sol': [Eq(log(x), C1 + exp(-f(x)/x)*sin(f(x)/x)/2 + exp(-f(x)/x)*cos(f(x)/x)/2)],
+ 'slow': True
+ },
+
+ 'dep_div_indep_04': {
+ 'eq': f(x).diff(x) - f(x)/x + 1/sin(f(x)/x),
+ 'sol': [Eq(f(x), x*(-acos(C1 + log(x)) + 2*pi)), Eq(f(x), x*acos(C1 + log(x)))],
+ 'slow': True
+ },
+
+ # previous code was testing with these other solution:
+ # example5_solb = Eq(f(x), log(log(C1/x)**(-x)))
+ 'dep_div_indep_05': {
+ 'eq': x*exp(f(x)/x) + f(x) - x*f(x).diff(x),
+ 'sol': [Eq(f(x), log((1/(C1 - log(x)))**x))],
+ 'checkodesol_XFAIL':True, #(because of **x?)
+ },
+ }
+ }
+
+@_add_example_keys
+def _get_examples_ode_sol_linear_coefficients():
+ return {
+ 'hint': "linear_coefficients",
+ 'func': f(x),
+ 'examples':{
+ 'linear_coeff_01': {
+ 'eq': f(x).diff(x) + (3 + 2*f(x))/(x + 3),
+ 'sol': [Eq(f(x), C1/(x**2 + 6*x + 9) - Rational(3, 2))],
+ },
+ }
+ }
+
+@_add_example_keys
+def _get_examples_ode_sol_1st_homogeneous_coeff_best():
+ return {
+ 'hint': "1st_homogeneous_coeff_best",
+ 'func': f(x),
+ 'examples':{
+ # previous code was testing this with other solution:
+ # example1_solb = Eq(-f(x)/(1 + log(x/f(x))), C1)
+ '1st_homogeneous_coeff_best_01': {
+ 'eq': f(x) + (x*log(f(x)/x) - 2*x)*diff(f(x), x),
+ 'sol': [Eq(f(x), -exp(C1)*LambertW(-x*exp(-C1 + 1)))],
+ 'checkodesol_XFAIL':True, #(because of LambertW?)
+ },
+
+ '1st_homogeneous_coeff_best_02': {
+ 'eq': 2*f(x)*exp(x/f(x)) + f(x)*f(x).diff(x) - 2*x*exp(x/f(x))*f(x).diff(x),
+ 'sol': [Eq(log(f(x)), C1 - 2*exp(x/f(x)))],
+ },
+
+ # previous code was testing this with other solution:
+ # example3_solb = Eq(log(C1*x*sqrt(1/x)*sqrt(f(x))) + x**2/(2*f(x)**2), 0)
+ '1st_homogeneous_coeff_best_03': {
+ 'eq': 2*x**2*f(x) + f(x)**3 + (x*f(x)**2 - 2*x**3)*f(x).diff(x),
+ 'sol': [Eq(f(x), exp(2*C1 + LambertW(-2*x**4*exp(-4*C1))/2)/x)],
+ 'checkodesol_XFAIL':True, #(because of LambertW?)
+ },
+
+ '1st_homogeneous_coeff_best_04': {
+ 'eq': (x + sqrt(f(x)**2 - x*f(x)))*f(x).diff(x) - f(x),
+ 'sol': [Eq(log(f(x)), C1 - 2*sqrt(-x/f(x) + 1))],
+ 'slow': True,
+ },
+
+ '1st_homogeneous_coeff_best_05': {
+ 'eq': x + f(x) - (x - f(x))*f(x).diff(x),
+ 'sol': [Eq(log(x), C1 - log(sqrt(1 + f(x)**2/x**2)) + atan(f(x)/x))],
+ },
+
+ '1st_homogeneous_coeff_best_06': {
+ 'eq': x*f(x).diff(x) - f(x) - x*sin(f(x)/x),
+ 'sol': [Eq(f(x), 2*x*atan(C1*x))],
+ },
+
+ '1st_homogeneous_coeff_best_07': {
+ 'eq': x**2 + f(x)**2 - 2*x*f(x)*f(x).diff(x),
+ 'sol': [Eq(f(x), -sqrt(x*(C1 + x))), Eq(f(x), sqrt(x*(C1 + x)))],
+ },
+
+ '1st_homogeneous_coeff_best_08': {
+ 'eq': f(x)**2 + (x*sqrt(f(x)**2 - x**2) - x*f(x))*f(x).diff(x),
+ 'sol': [Eq(f(x), -sqrt(-x*exp(2*C1)/(x - 2*exp(C1)))), Eq(f(x), sqrt(-x*exp(2*C1)/(x - 2*exp(C1))))],
+ 'checkodesol_XFAIL': True # solutions are valid in a range
+ },
+ }
+ }
+
+
+def _get_all_examples():
+ all_examples = _get_examples_ode_sol_euler_homogeneous + \
+ _get_examples_ode_sol_euler_undetermined_coeff + \
+ _get_examples_ode_sol_euler_var_para + \
+ _get_examples_ode_sol_factorable + \
+ _get_examples_ode_sol_bernoulli + \
+ _get_examples_ode_sol_nth_algebraic + \
+ _get_examples_ode_sol_riccati + \
+ _get_examples_ode_sol_1st_linear + \
+ _get_examples_ode_sol_1st_exact + \
+ _get_examples_ode_sol_almost_linear + \
+ _get_examples_ode_sol_nth_order_reducible + \
+ _get_examples_ode_sol_nth_linear_undetermined_coefficients + \
+ _get_examples_ode_sol_liouville + \
+ _get_examples_ode_sol_separable + \
+ _get_examples_ode_sol_1st_rational_riccati + \
+ _get_examples_ode_sol_nth_linear_var_of_parameters + \
+ _get_examples_ode_sol_2nd_linear_bessel + \
+ _get_examples_ode_sol_2nd_2F1_hypergeometric + \
+ _get_examples_ode_sol_2nd_nonlinear_autonomous_conserved + \
+ _get_examples_ode_sol_separable_reduced + \
+ _get_examples_ode_sol_lie_group + \
+ _get_examples_ode_sol_2nd_linear_airy + \
+ _get_examples_ode_sol_nth_linear_constant_coeff_homogeneous +\
+ _get_examples_ode_sol_1st_homogeneous_coeff_best +\
+ _get_examples_ode_sol_1st_homogeneous_coeff_subs_dep_div_indep +\
+ _get_examples_ode_sol_linear_coefficients
+
+ return all_examples
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_subscheck.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_subscheck.py
new file mode 100644
index 0000000000000000000000000000000000000000..799c2854e878208721b600767de350cda08cd7e5
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_subscheck.py
@@ -0,0 +1,203 @@
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.error_functions import (Ei, erf, erfi)
+from sympy.integrals.integrals import Integral
+
+from sympy.solvers.ode.subscheck import checkodesol, checksysodesol
+
+from sympy.functions import besselj, bessely
+
+from sympy.testing.pytest import raises, slow
+
+
+C0, C1, C2, C3, C4 = symbols('C0:5')
+u, x, y, z = symbols('u,x:z', real=True)
+f = Function('f')
+g = Function('g')
+h = Function('h')
+
+
+@slow
+def test_checkodesol():
+ # For the most part, checkodesol is well tested in the tests below.
+ # These tests only handle cases not checked below.
+ raises(ValueError, lambda: checkodesol(f(x, y).diff(x), Eq(f(x, y), x)))
+ raises(ValueError, lambda: checkodesol(f(x).diff(x), Eq(f(x, y),
+ x), f(x, y)))
+ assert checkodesol(f(x).diff(x), Eq(f(x, y), x)) == \
+ (False, -f(x).diff(x) + f(x, y).diff(x) - 1)
+ assert checkodesol(f(x).diff(x), Eq(f(x), x)) is not True
+ assert checkodesol(f(x).diff(x), Eq(f(x), x)) == (False, 1)
+ sol1 = Eq(f(x)**5 + 11*f(x) - 2*f(x) + x, 0)
+ assert checkodesol(diff(sol1.lhs, x), sol1) == (True, 0)
+ assert checkodesol(diff(sol1.lhs, x)*exp(f(x)), sol1) == (True, 0)
+ assert checkodesol(diff(sol1.lhs, x, 2), sol1) == (True, 0)
+ assert checkodesol(diff(sol1.lhs, x, 2)*exp(f(x)), sol1) == (True, 0)
+ assert checkodesol(diff(sol1.lhs, x, 3), sol1) == (True, 0)
+ assert checkodesol(diff(sol1.lhs, x, 3)*exp(f(x)), sol1) == (True, 0)
+ assert checkodesol(diff(sol1.lhs, x, 3), Eq(f(x), x*log(x))) == \
+ (False, 60*x**4*((log(x) + 1)**2 + log(x))*(
+ log(x) + 1)*log(x)**2 - 5*x**4*log(x)**4 - 9)
+ assert checkodesol(diff(exp(f(x)) + x, x)*x, Eq(exp(f(x)) + x, 0)) == \
+ (True, 0)
+ assert checkodesol(diff(exp(f(x)) + x, x)*x, Eq(exp(f(x)) + x, 0),
+ solve_for_func=False) == (True, 0)
+ assert checkodesol(f(x).diff(x, 2), [Eq(f(x), C1 + C2*x),
+ Eq(f(x), C2 + C1*x), Eq(f(x), C1*x + C2*x**2)]) == \
+ [(True, 0), (True, 0), (False, C2)]
+ assert checkodesol(f(x).diff(x, 2), {Eq(f(x), C1 + C2*x),
+ Eq(f(x), C2 + C1*x), Eq(f(x), C1*x + C2*x**2)}) == \
+ {(True, 0), (True, 0), (False, C2)}
+ assert checkodesol(f(x).diff(x) - 1/f(x)/2, Eq(f(x)**2, x)) == \
+ [(True, 0), (True, 0)]
+ assert checkodesol(f(x).diff(x) - f(x), Eq(C1*exp(x), f(x))) == (True, 0)
+ # Based on test_1st_homogeneous_coeff_ode2_eq3sol. Make sure that
+ # checkodesol tries back substituting f(x) when it can.
+ eq3 = x*exp(f(x)/x) + f(x) - x*f(x).diff(x)
+ sol3 = Eq(f(x), log(log(C1/x)**(-x)))
+ assert not checkodesol(eq3, sol3)[1].has(f(x))
+ # This case was failing intermittently depending on hash-seed:
+ eqn = Eq(Derivative(x*Derivative(f(x), x), x)/x, exp(x))
+ sol = Eq(f(x), C1 + C2*log(x) + exp(x) - Ei(x))
+ assert checkodesol(eqn, sol, order=2, solve_for_func=False)[0]
+ eq = x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (2*x**2 +25)*f(x)
+ sol = Eq(f(x), C1*besselj(5*I, sqrt(2)*x) + C2*bessely(5*I, sqrt(2)*x))
+ assert checkodesol(eq, sol) == (True, 0)
+
+ eqs = [Eq(f(x).diff(x), f(x) + g(x)), Eq(g(x).diff(x), f(x) + g(x))]
+ sol = [Eq(f(x), -C1 + C2*exp(2*x)), Eq(g(x), C1 + C2*exp(2*x))]
+ assert checkodesol(eqs, sol) == (True, [0, 0])
+
+
+def test_checksysodesol():
+ x, y, z = symbols('x, y, z', cls=Function)
+ t = Symbol('t')
+ eq = (Eq(diff(x(t),t), 9*y(t)), Eq(diff(y(t),t), 12*x(t)))
+ sol = [Eq(x(t), 9*C1*exp(-6*sqrt(3)*t) + 9*C2*exp(6*sqrt(3)*t)), \
+ Eq(y(t), -6*sqrt(3)*C1*exp(-6*sqrt(3)*t) + 6*sqrt(3)*C2*exp(6*sqrt(3)*t))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(diff(x(t),t), 2*x(t) + 4*y(t)), Eq(diff(y(t),t), 12*x(t) + 41*y(t)))
+ sol = [Eq(x(t), 4*C1*exp(t*(-sqrt(1713)/2 + Rational(43, 2))) + 4*C2*exp(t*(sqrt(1713)/2 + \
+ Rational(43, 2)))), Eq(y(t), C1*(-sqrt(1713)/2 + Rational(39, 2))*exp(t*(-sqrt(1713)/2 + \
+ Rational(43, 2))) + C2*(Rational(39, 2) + sqrt(1713)/2)*exp(t*(sqrt(1713)/2 + Rational(43, 2))))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(diff(x(t),t), x(t) + y(t)), Eq(diff(y(t),t), -2*x(t) + 2*y(t)))
+ sol = [Eq(x(t), (C1*sin(sqrt(7)*t/2) + C2*cos(sqrt(7)*t/2))*exp(t*Rational(3, 2))), \
+ Eq(y(t), ((C1/2 - sqrt(7)*C2/2)*sin(sqrt(7)*t/2) + (sqrt(7)*C1/2 + \
+ C2/2)*cos(sqrt(7)*t/2))*exp(t*Rational(3, 2)))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(diff(x(t),t), x(t) + y(t) + 9), Eq(diff(y(t),t), 2*x(t) + 5*y(t) + 23))
+ sol = [Eq(x(t), C1*exp(t*(-sqrt(6) + 3)) + C2*exp(t*(sqrt(6) + 3)) - \
+ Rational(22, 3)), Eq(y(t), C1*(-sqrt(6) + 2)*exp(t*(-sqrt(6) + 3)) + C2*(2 + \
+ sqrt(6))*exp(t*(sqrt(6) + 3)) - Rational(5, 3))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(diff(x(t),t), x(t) + y(t) + 81), Eq(diff(y(t),t), -2*x(t) + y(t) + 23))
+ sol = [Eq(x(t), (C1*sin(sqrt(2)*t) + C2*cos(sqrt(2)*t))*exp(t) - Rational(58, 3)), \
+ Eq(y(t), (sqrt(2)*C1*cos(sqrt(2)*t) - sqrt(2)*C2*sin(sqrt(2)*t))*exp(t) - Rational(185, 3))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(diff(x(t),t), 5*t*x(t) + 2*y(t)), Eq(diff(y(t),t), 2*x(t) + 5*t*y(t)))
+ sol = [Eq(x(t), (C1*exp(Integral(2, t).doit()) + C2*exp(-(Integral(2, t)).doit()))*\
+ exp((Integral(5*t, t)).doit())), Eq(y(t), (C1*exp((Integral(2, t)).doit()) - \
+ C2*exp(-(Integral(2, t)).doit()))*exp((Integral(5*t, t)).doit()))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t)), Eq(diff(y(t),t), -t**2*x(t) + 5*t*y(t)))
+ sol = [Eq(x(t), (C1*cos((Integral(t**2, t)).doit()) + C2*sin((Integral(t**2, t)).doit()))*\
+ exp((Integral(5*t, t)).doit())), Eq(y(t), (-C1*sin((Integral(t**2, t)).doit()) + \
+ C2*cos((Integral(t**2, t)).doit()))*exp((Integral(5*t, t)).doit()))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t)), Eq(diff(y(t),t), -t**2*x(t) + (5*t+9*t**2)*y(t)))
+ sol = [Eq(x(t), (C1*exp((-sqrt(77)/2 + Rational(9, 2))*(Integral(t**2, t)).doit()) + \
+ C2*exp((sqrt(77)/2 + Rational(9, 2))*(Integral(t**2, t)).doit()))*exp((Integral(5*t, t)).doit())), \
+ Eq(y(t), (C1*(-sqrt(77)/2 + Rational(9, 2))*exp((-sqrt(77)/2 + Rational(9, 2))*(Integral(t**2, t)).doit()) + \
+ C2*(sqrt(77)/2 + Rational(9, 2))*exp((sqrt(77)/2 + Rational(9, 2))*(Integral(t**2, t)).doit()))*exp((Integral(5*t, t)).doit()))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(diff(x(t),t,t), 5*x(t) + 43*y(t)), Eq(diff(y(t),t,t), x(t) + 9*y(t)))
+ root0 = -sqrt(-sqrt(47) + 7)
+ root1 = sqrt(-sqrt(47) + 7)
+ root2 = -sqrt(sqrt(47) + 7)
+ root3 = sqrt(sqrt(47) + 7)
+ sol = [Eq(x(t), 43*C1*exp(t*root0) + 43*C2*exp(t*root1) + 43*C3*exp(t*root2) + 43*C4*exp(t*root3)), \
+ Eq(y(t), C1*(root0**2 - 5)*exp(t*root0) + C2*(root1**2 - 5)*exp(t*root1) + \
+ C3*(root2**2 - 5)*exp(t*root2) + C4*(root3**2 - 5)*exp(t*root3))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(diff(x(t),t,t), 8*x(t)+3*y(t)+31), Eq(diff(y(t),t,t), 9*x(t)+7*y(t)+12))
+ root0 = -sqrt(-sqrt(109)/2 + Rational(15, 2))
+ root1 = sqrt(-sqrt(109)/2 + Rational(15, 2))
+ root2 = -sqrt(sqrt(109)/2 + Rational(15, 2))
+ root3 = sqrt(sqrt(109)/2 + Rational(15, 2))
+ sol = [Eq(x(t), 3*C1*exp(t*root0) + 3*C2*exp(t*root1) + 3*C3*exp(t*root2) + 3*C4*exp(t*root3) - Rational(181, 29)), \
+ Eq(y(t), C1*(root0**2 - 8)*exp(t*root0) + C2*(root1**2 - 8)*exp(t*root1) + \
+ C3*(root2**2 - 8)*exp(t*root2) + C4*(root3**2 - 8)*exp(t*root3) + Rational(183, 29))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(diff(x(t),t,t) - 9*diff(y(t),t) + 7*x(t),0), Eq(diff(y(t),t,t) + 9*diff(x(t),t) + 7*y(t),0))
+ sol = [Eq(x(t), C1*cos(t*(Rational(9, 2) + sqrt(109)/2)) + C2*sin(t*(Rational(9, 2) + sqrt(109)/2)) + \
+ C3*cos(t*(-sqrt(109)/2 + Rational(9, 2))) + C4*sin(t*(-sqrt(109)/2 + Rational(9, 2)))), Eq(y(t), -C1*sin(t*(Rational(9, 2) + sqrt(109)/2)) \
+ + C2*cos(t*(Rational(9, 2) + sqrt(109)/2)) - C3*sin(t*(-sqrt(109)/2 + Rational(9, 2))) + C4*cos(t*(-sqrt(109)/2 + Rational(9, 2))))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(diff(x(t),t,t), 9*t*diff(y(t),t)-9*y(t)), Eq(diff(y(t),t,t),7*t*diff(x(t),t)-7*x(t)))
+ I1 = sqrt(6)*7**Rational(1, 4)*sqrt(pi)*erfi(sqrt(6)*7**Rational(1, 4)*t/2)/2 - exp(3*sqrt(7)*t**2/2)/t
+ I2 = -sqrt(6)*7**Rational(1, 4)*sqrt(pi)*erf(sqrt(6)*7**Rational(1, 4)*t/2)/2 - exp(-3*sqrt(7)*t**2/2)/t
+ sol = [Eq(x(t), C3*t + t*(9*C1*I1 + 9*C2*I2)), Eq(y(t), C4*t + t*(3*sqrt(7)*C1*I1 - 3*sqrt(7)*C2*I2))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(diff(x(t),t), 21*x(t)), Eq(diff(y(t),t), 17*x(t)+3*y(t)), Eq(diff(z(t),t), 5*x(t)+7*y(t)+9*z(t)))
+ sol = [Eq(x(t), C1*exp(21*t)), Eq(y(t), 17*C1*exp(21*t)/18 + C2*exp(3*t)), \
+ Eq(z(t), 209*C1*exp(21*t)/216 - 7*C2*exp(3*t)/6 + C3*exp(9*t))]
+ assert checksysodesol(eq, sol) == (True, [0, 0, 0])
+
+ eq = (Eq(diff(x(t),t),3*y(t)-11*z(t)),Eq(diff(y(t),t),7*z(t)-3*x(t)),Eq(diff(z(t),t),11*x(t)-7*y(t)))
+ sol = [Eq(x(t), 7*C0 + sqrt(179)*C1*cos(sqrt(179)*t) + (77*C1/3 + 130*C2/3)*sin(sqrt(179)*t)), \
+ Eq(y(t), 11*C0 + sqrt(179)*C2*cos(sqrt(179)*t) + (-58*C1/3 - 77*C2/3)*sin(sqrt(179)*t)), \
+ Eq(z(t), 3*C0 + sqrt(179)*(-7*C1/3 - 11*C2/3)*cos(sqrt(179)*t) + (11*C1 - 7*C2)*sin(sqrt(179)*t))]
+ assert checksysodesol(eq, sol) == (True, [0, 0, 0])
+
+ eq = (Eq(3*diff(x(t),t),4*5*(y(t)-z(t))),Eq(4*diff(y(t),t),3*5*(z(t)-x(t))),Eq(5*diff(z(t),t),3*4*(x(t)-y(t))))
+ sol = [Eq(x(t), C0 + 5*sqrt(2)*C1*cos(5*sqrt(2)*t) + (12*C1/5 + 164*C2/15)*sin(5*sqrt(2)*t)), \
+ Eq(y(t), C0 + 5*sqrt(2)*C2*cos(5*sqrt(2)*t) + (-51*C1/10 - 12*C2/5)*sin(5*sqrt(2)*t)), \
+ Eq(z(t), C0 + 5*sqrt(2)*(-9*C1/25 - 16*C2/25)*cos(5*sqrt(2)*t) + (12*C1/5 - 12*C2/5)*sin(5*sqrt(2)*t))]
+ assert checksysodesol(eq, sol) == (True, [0, 0, 0])
+
+ eq = (Eq(diff(x(t),t),4*x(t) - z(t)),Eq(diff(y(t),t),2*x(t)+2*y(t)-z(t)),Eq(diff(z(t),t),3*x(t)+y(t)))
+ sol = [Eq(x(t), C1*exp(2*t) + C2*t*exp(2*t) + C2*exp(2*t) + C3*t**2*exp(2*t)/2 + C3*t*exp(2*t) + C3*exp(2*t)), \
+ Eq(y(t), C1*exp(2*t) + C2*t*exp(2*t) + C2*exp(2*t) + C3*t**2*exp(2*t)/2 + C3*t*exp(2*t)), \
+ Eq(z(t), 2*C1*exp(2*t) + 2*C2*t*exp(2*t) + C2*exp(2*t) + C3*t**2*exp(2*t) + C3*t*exp(2*t) + C3*exp(2*t))]
+ assert checksysodesol(eq, sol) == (True, [0, 0, 0])
+
+ eq = (Eq(diff(x(t),t),4*x(t) - y(t) - 2*z(t)),Eq(diff(y(t),t),2*x(t) + y(t)- 2*z(t)),Eq(diff(z(t),t),5*x(t)-3*z(t)))
+ sol = [Eq(x(t), C1*exp(2*t) + C2*(-sin(t) + 3*cos(t)) + C3*(3*sin(t) + cos(t))), \
+ Eq(y(t), C2*(-sin(t) + 3*cos(t)) + C3*(3*sin(t) + cos(t))), Eq(z(t), C1*exp(2*t) + 5*C2*cos(t) + 5*C3*sin(t))]
+ assert checksysodesol(eq, sol) == (True, [0, 0, 0])
+
+ eq = (Eq(diff(x(t),t),x(t)*y(t)**3), Eq(diff(y(t),t),y(t)**5))
+ sol = [Eq(x(t), C1*exp((-1/(4*C2 + 4*t))**(Rational(-1, 4)))), Eq(y(t), -(-1/(4*C2 + 4*t))**Rational(1, 4)), \
+ Eq(x(t), C1*exp(-1/(-1/(4*C2 + 4*t))**Rational(1, 4))), Eq(y(t), (-1/(4*C2 + 4*t))**Rational(1, 4)), \
+ Eq(x(t), C1*exp(-I/(-1/(4*C2 + 4*t))**Rational(1, 4))), Eq(y(t), -I*(-1/(4*C2 + 4*t))**Rational(1, 4)), \
+ Eq(x(t), C1*exp(I/(-1/(4*C2 + 4*t))**Rational(1, 4))), Eq(y(t), I*(-1/(4*C2 + 4*t))**Rational(1, 4))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(diff(x(t),t), exp(3*x(t))*y(t)**3),Eq(diff(y(t),t), y(t)**5))
+ sol = [Eq(x(t), -log(C1 - 3/(-1/(4*C2 + 4*t))**Rational(1, 4))/3), Eq(y(t), -(-1/(4*C2 + 4*t))**Rational(1, 4)), \
+ Eq(x(t), -log(C1 + 3/(-1/(4*C2 + 4*t))**Rational(1, 4))/3), Eq(y(t), (-1/(4*C2 + 4*t))**Rational(1, 4)), \
+ Eq(x(t), -log(C1 + 3*I/(-1/(4*C2 + 4*t))**Rational(1, 4))/3), Eq(y(t), -I*(-1/(4*C2 + 4*t))**Rational(1, 4)), \
+ Eq(x(t), -log(C1 - 3*I/(-1/(4*C2 + 4*t))**Rational(1, 4))/3), Eq(y(t), I*(-1/(4*C2 + 4*t))**Rational(1, 4))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+ eq = (Eq(x(t),t*diff(x(t),t)+diff(x(t),t)*diff(y(t),t)), Eq(y(t),t*diff(y(t),t)+diff(y(t),t)**2))
+ sol = {Eq(x(t), C1*C2 + C1*t), Eq(y(t), C2**2 + C2*t)}
+ assert checksysodesol(eq, sol) == (True, [0, 0])
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_systems.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_systems.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1c364711d60f35973ecb64dc2ba9815c11a8c0a
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/ode/tests/test_systems.py
@@ -0,0 +1,2560 @@
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.hyperbolic import sinh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import Matrix
+from sympy.core.containers import Tuple
+from sympy.functions import exp, cos, sin, log, Ci, Si, erf, erfi
+from sympy.matrices import dotprodsimp, NonSquareMatrixError
+from sympy.solvers.ode import dsolve
+from sympy.solvers.ode.ode import constant_renumber
+from sympy.solvers.ode.subscheck import checksysodesol
+from sympy.solvers.ode.systems import (_classify_linear_system, linear_ode_to_matrix,
+ ODEOrderError, ODENonlinearError, _simpsol,
+ _is_commutative_anti_derivative, linodesolve,
+ canonical_odes, dsolve_system, _component_division,
+ _eqs2dict, _dict2graph)
+from sympy.functions import airyai, airybi
+from sympy.integrals.integrals import Integral
+from sympy.simplify.ratsimp import ratsimp
+from sympy.testing.pytest import ON_CI, raises, slow, skip, XFAIL
+
+
+C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 = symbols('C0:11')
+x = symbols('x')
+f = Function('f')
+g = Function('g')
+h = Function('h')
+
+
+def test_linear_ode_to_matrix():
+ f, g, h = symbols("f, g, h", cls=Function)
+ t = Symbol("t")
+ funcs = [f(t), g(t), h(t)]
+ f1 = f(t).diff(t)
+ g1 = g(t).diff(t)
+ h1 = h(t).diff(t)
+ f2 = f(t).diff(t, 2)
+ g2 = g(t).diff(t, 2)
+ h2 = h(t).diff(t, 2)
+
+ eqs_1 = [Eq(f1, g(t)), Eq(g1, f(t))]
+ sol_1 = ([Matrix([[1, 0], [0, 1]]), Matrix([[ 0, 1], [1, 0]])], Matrix([[0],[0]]))
+ assert linear_ode_to_matrix(eqs_1, funcs[:-1], t, 1) == sol_1
+
+ eqs_2 = [Eq(f1, f(t) + 2*g(t)), Eq(g1, h(t)), Eq(h1, g(t) + h(t) + f(t))]
+ sol_2 = ([Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]]), Matrix([[1, 2, 0], [ 0, 0, 1], [1, 1, 1]])],
+ Matrix([[0], [0], [0]]))
+ assert linear_ode_to_matrix(eqs_2, funcs, t, 1) == sol_2
+
+ eqs_3 = [Eq(2*f1 + 3*h1, f(t) + g(t)), Eq(4*h1 + 5*g1, f(t) + h(t)), Eq(5*f1 + 4*g1, g(t) + h(t))]
+ sol_3 = ([Matrix([[2, 0, 3], [0, 5, 4], [5, 4, 0]]), Matrix([[1, 1, 0], [1, 0, 1], [0, 1, 1]])],
+ Matrix([[0], [0], [0]]))
+ assert linear_ode_to_matrix(eqs_3, funcs, t, 1) == sol_3
+
+ eqs_4 = [Eq(f2 + h(t), f1 + g(t)), Eq(2*h2 + g2 + g1 + g(t), 0), Eq(3*h1, 4)]
+ sol_4 = ([Matrix([[1, 0, 0], [0, 1, 2], [0, 0, 0]]), Matrix([[1, 0, 0], [0, -1, 0], [0, 0, -3]]),
+ Matrix([[0, 1, -1], [0, -1, 0], [0, 0, 0]])], Matrix([[0], [0], [4]]))
+ assert linear_ode_to_matrix(eqs_4, funcs, t, 2) == sol_4
+
+ eqs_5 = [Eq(f2, g(t)), Eq(f1 + g1, f(t))]
+ raises(ODEOrderError, lambda: linear_ode_to_matrix(eqs_5, funcs[:-1], t, 1))
+
+ eqs_6 = [Eq(f1, f(t)**2), Eq(g1, f(t) + g(t))]
+ raises(ODENonlinearError, lambda: linear_ode_to_matrix(eqs_6, funcs[:-1], t, 1))
+
+
+def test__classify_linear_system():
+ x, y, z, w = symbols('x, y, z, w', cls=Function)
+ t, k, l = symbols('t k l')
+ x1 = diff(x(t), t)
+ y1 = diff(y(t), t)
+ z1 = diff(z(t), t)
+ w1 = diff(w(t), t)
+ x2 = diff(x(t), t, t)
+ y2 = diff(y(t), t, t)
+ funcs = [x(t), y(t)]
+ funcs_2 = funcs + [z(t), w(t)]
+
+ eqs_1 = (5 * x1 + 12 * x(t) - 6 * (y(t)), (2 * y1 - 11 * t * x(t) + 3 * y(t) + t))
+ assert _classify_linear_system(eqs_1, funcs, t) is None
+
+ eqs_2 = (5 * (x1**2) + 12 * x(t) - 6 * (y(t)), (2 * y1 - 11 * t * x(t) + 3 * y(t) + t))
+ sol2 = {'is_implicit': True,
+ 'canon_eqs': [[Eq(Derivative(x(t), t), -sqrt(-12*x(t)/5 + 6*y(t)/5)),
+ Eq(Derivative(y(t), t), 11*t*x(t)/2 - t/2 - 3*y(t)/2)],
+ [Eq(Derivative(x(t), t), sqrt(-12*x(t)/5 + 6*y(t)/5)),
+ Eq(Derivative(y(t), t), 11*t*x(t)/2 - t/2 - 3*y(t)/2)]]}
+ assert _classify_linear_system(eqs_2, funcs, t) == sol2
+
+ eqs_2_1 = [Eq(Derivative(x(t), t), -sqrt(-12*x(t)/5 + 6*y(t)/5)),
+ Eq(Derivative(y(t), t), 11*t*x(t)/2 - t/2 - 3*y(t)/2)]
+ assert _classify_linear_system(eqs_2_1, funcs, t) is None
+
+ eqs_2_2 = [Eq(Derivative(x(t), t), sqrt(-12*x(t)/5 + 6*y(t)/5)),
+ Eq(Derivative(y(t), t), 11*t*x(t)/2 - t/2 - 3*y(t)/2)]
+ assert _classify_linear_system(eqs_2_2, funcs, t) is None
+
+ eqs_3 = (5 * x1 + 12 * x(t) - 6 * (y(t)), (2 * y1 - 11 * x(t) + 3 * y(t)), (5 * w1 + z(t)), (z1 + w(t)))
+ answer_3 = {'no_of_equation': 4,
+ 'eq': (12*x(t) - 6*y(t) + 5*Derivative(x(t), t),
+ -11*x(t) + 3*y(t) + 2*Derivative(y(t), t),
+ z(t) + 5*Derivative(w(t), t),
+ w(t) + Derivative(z(t), t)),
+ 'func': [x(t), y(t), z(t), w(t)],
+ 'order': {x(t): 1, y(t): 1, z(t): 1, w(t): 1},
+ 'is_linear': True,
+ 'is_constant': True,
+ 'is_homogeneous': True,
+ 'func_coeff': -Matrix([
+ [Rational(12, 5), Rational(-6, 5), 0, 0],
+ [Rational(-11, 2), Rational(3, 2), 0, 0],
+ [0, 0, 0, 1],
+ [0, 0, Rational(1, 5), 0]]),
+ 'type_of_equation': 'type1',
+ 'is_general': True}
+ assert _classify_linear_system(eqs_3, funcs_2, t) == answer_3
+
+ eqs_4 = (5 * x1 + 12 * x(t) - 6 * (y(t)), (2 * y1 - 11 * x(t) + 3 * y(t)), (z1 - w(t)), (w1 - z(t)))
+ answer_4 = {'no_of_equation': 4,
+ 'eq': (12 * x(t) - 6 * y(t) + 5 * Derivative(x(t), t),
+ -11 * x(t) + 3 * y(t) + 2 * Derivative(y(t), t),
+ -w(t) + Derivative(z(t), t),
+ -z(t) + Derivative(w(t), t)),
+ 'func': [x(t), y(t), z(t), w(t)],
+ 'order': {x(t): 1, y(t): 1, z(t): 1, w(t): 1},
+ 'is_linear': True,
+ 'is_constant': True,
+ 'is_homogeneous': True,
+ 'func_coeff': -Matrix([
+ [Rational(12, 5), Rational(-6, 5), 0, 0],
+ [Rational(-11, 2), Rational(3, 2), 0, 0],
+ [0, 0, 0, -1],
+ [0, 0, -1, 0]]),
+ 'type_of_equation': 'type1',
+ 'is_general': True}
+ assert _classify_linear_system(eqs_4, funcs_2, t) == answer_4
+
+ eqs_5 = (5*x1 + 12*x(t) - 6*(y(t)) + x2, (2*y1 - 11*x(t) + 3*y(t)), (z1 - w(t)), (w1 - z(t)))
+ answer_5 = {'no_of_equation': 4, 'eq': (12*x(t) - 6*y(t) + 5*Derivative(x(t), t) + Derivative(x(t), (t, 2)),
+ -11*x(t) + 3*y(t) + 2*Derivative(y(t), t), -w(t) + Derivative(z(t), t), -z(t) + Derivative(w(t),
+ t)), 'func': [x(t), y(t), z(t), w(t)], 'order': {x(t): 2, y(t): 1, z(t): 1, w(t): 1}, 'is_linear':
+ True, 'is_homogeneous': True, 'is_general': True, 'type_of_equation': 'type0', 'is_higher_order': True}
+ assert _classify_linear_system(eqs_5, funcs_2, t) == answer_5
+
+ eqs_6 = (Eq(x1, 3*y(t) - 11*z(t)), Eq(y1, 7*z(t) - 3*x(t)), Eq(z1, 11*x(t) - 7*y(t)))
+ answer_6 = {'no_of_equation': 3, 'eq': (Eq(Derivative(x(t), t), 3*y(t) - 11*z(t)), Eq(Derivative(y(t), t), -3*x(t) + 7*z(t)),
+ Eq(Derivative(z(t), t), 11*x(t) - 7*y(t))), 'func': [x(t), y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1},
+ 'is_linear': True, 'is_constant': True, 'is_homogeneous': True,
+ 'func_coeff': -Matrix([
+ [ 0, -3, 11],
+ [ 3, 0, -7],
+ [-11, 7, 0]]),
+ 'type_of_equation': 'type1', 'is_general': True}
+
+ assert _classify_linear_system(eqs_6, funcs_2[:-1], t) == answer_6
+
+ eqs_7 = (Eq(x1, y(t)), Eq(y1, x(t)))
+ answer_7 = {'no_of_equation': 2, 'eq': (Eq(Derivative(x(t), t), y(t)), Eq(Derivative(y(t), t), x(t))),
+ 'func': [x(t), y(t)], 'order': {x(t): 1, y(t): 1}, 'is_linear': True, 'is_constant': True,
+ 'is_homogeneous': True, 'func_coeff': -Matrix([
+ [ 0, -1],
+ [-1, 0]]),
+ 'type_of_equation': 'type1', 'is_general': True}
+ assert _classify_linear_system(eqs_7, funcs, t) == answer_7
+
+ eqs_8 = (Eq(x1, 21*x(t)), Eq(y1, 17*x(t) + 3*y(t)), Eq(z1, 5*x(t) + 7*y(t) + 9*z(t)))
+ answer_8 = {'no_of_equation': 3, 'eq': (Eq(Derivative(x(t), t), 21*x(t)), Eq(Derivative(y(t), t), 17*x(t) + 3*y(t)),
+ Eq(Derivative(z(t), t), 5*x(t) + 7*y(t) + 9*z(t))), 'func': [x(t), y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1},
+ 'is_linear': True, 'is_constant': True, 'is_homogeneous': True,
+ 'func_coeff': -Matrix([
+ [-21, 0, 0],
+ [-17, -3, 0],
+ [ -5, -7, -9]]),
+ 'type_of_equation': 'type1', 'is_general': True}
+
+ assert _classify_linear_system(eqs_8, funcs_2[:-1], t) == answer_8
+
+ eqs_9 = (Eq(x1, 4*x(t) + 5*y(t) + 2*z(t)), Eq(y1, x(t) + 13*y(t) + 9*z(t)), Eq(z1, 32*x(t) + 41*y(t) + 11*z(t)))
+ answer_9 = {'no_of_equation': 3, 'eq': (Eq(Derivative(x(t), t), 4*x(t) + 5*y(t) + 2*z(t)),
+ Eq(Derivative(y(t), t), x(t) + 13*y(t) + 9*z(t)), Eq(Derivative(z(t), t), 32*x(t) + 41*y(t) + 11*z(t))),
+ 'func': [x(t), y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True,
+ 'is_constant': True, 'is_homogeneous': True,
+ 'func_coeff': -Matrix([
+ [ -4, -5, -2],
+ [ -1, -13, -9],
+ [-32, -41, -11]]),
+ 'type_of_equation': 'type1', 'is_general': True}
+ assert _classify_linear_system(eqs_9, funcs_2[:-1], t) == answer_9
+
+ eqs_10 = (Eq(3*x1, 4*5*(y(t) - z(t))), Eq(4*y1, 3*5*(z(t) - x(t))), Eq(5*z1, 3*4*(x(t) - y(t))))
+ answer_10 = {'no_of_equation': 3, 'eq': (Eq(3*Derivative(x(t), t), 20*y(t) - 20*z(t)),
+ Eq(4*Derivative(y(t), t), -15*x(t) + 15*z(t)), Eq(5*Derivative(z(t), t), 12*x(t) - 12*y(t))),
+ 'func': [x(t), y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True,
+ 'is_constant': True, 'is_homogeneous': True,
+ 'func_coeff': -Matrix([
+ [ 0, Rational(-20, 3), Rational(20, 3)],
+ [Rational(15, 4), 0, Rational(-15, 4)],
+ [Rational(-12, 5), Rational(12, 5), 0]]),
+ 'type_of_equation': 'type1', 'is_general': True}
+ assert _classify_linear_system(eqs_10, funcs_2[:-1], t) == answer_10
+
+ eq11 = (Eq(x1, 3*y(t) - 11*z(t)), Eq(y1, 7*z(t) - 3*x(t)), Eq(z1, 11*x(t) - 7*y(t)))
+ sol11 = {'no_of_equation': 3, 'eq': (Eq(Derivative(x(t), t), 3*y(t) - 11*z(t)), Eq(Derivative(y(t), t), -3*x(t) + 7*z(t)),
+ Eq(Derivative(z(t), t), 11*x(t) - 7*y(t))), 'func': [x(t), y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1},
+ 'is_linear': True, 'is_constant': True, 'is_homogeneous': True, 'func_coeff': -Matrix([
+ [ 0, -3, 11], [ 3, 0, -7], [-11, 7, 0]]), 'type_of_equation': 'type1', 'is_general': True}
+ assert _classify_linear_system(eq11, funcs_2[:-1], t) == sol11
+
+ eq12 = (Eq(Derivative(x(t), t), y(t)), Eq(Derivative(y(t), t), x(t)))
+ sol12 = {'no_of_equation': 2, 'eq': (Eq(Derivative(x(t), t), y(t)), Eq(Derivative(y(t), t), x(t))),
+ 'func': [x(t), y(t)], 'order': {x(t): 1, y(t): 1}, 'is_linear': True, 'is_constant': True,
+ 'is_homogeneous': True, 'func_coeff': -Matrix([
+ [0, -1],
+ [-1, 0]]), 'type_of_equation': 'type1', 'is_general': True}
+ assert _classify_linear_system(eq12, [x(t), y(t)], t) == sol12
+
+ eq13 = (Eq(Derivative(x(t), t), 21*x(t)), Eq(Derivative(y(t), t), 17*x(t) + 3*y(t)),
+ Eq(Derivative(z(t), t), 5*x(t) + 7*y(t) + 9*z(t)))
+ sol13 = {'no_of_equation': 3, 'eq': (
+ Eq(Derivative(x(t), t), 21 * x(t)), Eq(Derivative(y(t), t), 17 * x(t) + 3 * y(t)),
+ Eq(Derivative(z(t), t), 5 * x(t) + 7 * y(t) + 9 * z(t))), 'func': [x(t), y(t), z(t)],
+ 'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True, 'is_constant': True, 'is_homogeneous': True,
+ 'func_coeff': -Matrix([
+ [-21, 0, 0],
+ [-17, -3, 0],
+ [-5, -7, -9]]), 'type_of_equation': 'type1', 'is_general': True}
+ assert _classify_linear_system(eq13, [x(t), y(t), z(t)], t) == sol13
+
+ eq14 = (
+ Eq(Derivative(x(t), t), 4*x(t) + 5*y(t) + 2*z(t)), Eq(Derivative(y(t), t), x(t) + 13*y(t) + 9*z(t)),
+ Eq(Derivative(z(t), t), 32*x(t) + 41*y(t) + 11*z(t)))
+ sol14 = {'no_of_equation': 3, 'eq': (
+ Eq(Derivative(x(t), t), 4 * x(t) + 5 * y(t) + 2 * z(t)), Eq(Derivative(y(t), t), x(t) + 13 * y(t) + 9 * z(t)),
+ Eq(Derivative(z(t), t), 32 * x(t) + 41 * y(t) + 11 * z(t))), 'func': [x(t), y(t), z(t)],
+ 'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True, 'is_constant': True, 'is_homogeneous': True,
+ 'func_coeff': -Matrix([
+ [-4, -5, -2],
+ [-1, -13, -9],
+ [-32, -41, -11]]), 'type_of_equation': 'type1', 'is_general': True}
+ assert _classify_linear_system(eq14, [x(t), y(t), z(t)], t) == sol14
+
+ eq15 = (Eq(3*Derivative(x(t), t), 20*y(t) - 20*z(t)), Eq(4*Derivative(y(t), t), -15*x(t) + 15*z(t)),
+ Eq(5*Derivative(z(t), t), 12*x(t) - 12*y(t)))
+ sol15 = {'no_of_equation': 3, 'eq': (
+ Eq(3 * Derivative(x(t), t), 20 * y(t) - 20 * z(t)), Eq(4 * Derivative(y(t), t), -15 * x(t) + 15 * z(t)),
+ Eq(5 * Derivative(z(t), t), 12 * x(t) - 12 * y(t))), 'func': [x(t), y(t), z(t)],
+ 'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True, 'is_constant': True, 'is_homogeneous': True,
+ 'func_coeff': -Matrix([
+ [0, Rational(-20, 3), Rational(20, 3)],
+ [Rational(15, 4), 0, Rational(-15, 4)],
+ [Rational(-12, 5), Rational(12, 5), 0]]), 'type_of_equation': 'type1', 'is_general': True}
+ assert _classify_linear_system(eq15, [x(t), y(t), z(t)], t) == sol15
+
+ # Constant coefficient homogeneous ODEs
+ eq1 = (Eq(diff(x(t), t), x(t) + y(t) + 9), Eq(diff(y(t), t), 2*x(t) + 5*y(t) + 23))
+ sol1 = {'no_of_equation': 2, 'eq': (Eq(Derivative(x(t), t), x(t) + y(t) + 9),
+ Eq(Derivative(y(t), t), 2*x(t) + 5*y(t) + 23)), 'func': [x(t), y(t)],
+ 'order': {x(t): 1, y(t): 1}, 'is_linear': True, 'is_constant': True, 'is_homogeneous': False, 'is_general': True,
+ 'func_coeff': -Matrix([[-1, -1], [-2, -5]]), 'rhs': Matrix([[ 9], [23]]), 'type_of_equation': 'type2'}
+ assert _classify_linear_system(eq1, funcs, t) == sol1
+
+ # Non constant coefficient homogeneous ODEs
+ eq1 = (Eq(diff(x(t), t), 5*t*x(t) + 2*y(t)), Eq(diff(y(t), t), 2*x(t) + 5*t*y(t)))
+ sol1 = {'no_of_equation': 2, 'eq': (Eq(Derivative(x(t), t), 5*t*x(t) + 2*y(t)), Eq(Derivative(y(t), t), 5*t*y(t) + 2*x(t))),
+ 'func': [x(t), y(t)], 'order': {x(t): 1, y(t): 1}, 'is_linear': True, 'is_constant': False,
+ 'is_homogeneous': True, 'func_coeff': -Matrix([ [-5*t, -2], [ -2, -5*t]]), 'commutative_antiderivative': Matrix([
+ [5*t**2/2, 2*t], [ 2*t, 5*t**2/2]]), 'type_of_equation': 'type3', 'is_general': True}
+ assert _classify_linear_system(eq1, funcs, t) == sol1
+
+ # Non constant coefficient non-homogeneous ODEs
+ eq1 = [Eq(x1, x(t) + t*y(t) + t), Eq(y1, t*x(t) + y(t))]
+ sol1 = {'no_of_equation': 2, 'eq': [Eq(Derivative(x(t), t), t*y(t) + t + x(t)), Eq(Derivative(y(t), t),
+ t*x(t) + y(t))], 'func': [x(t), y(t)], 'order': {x(t): 1, y(t): 1}, 'is_linear': True,
+ 'is_constant': False, 'is_homogeneous': False, 'is_general': True, 'func_coeff': -Matrix([ [-1, -t],
+ [-t, -1]]), 'commutative_antiderivative': Matrix([ [ t, t**2/2], [t**2/2, t]]), 'rhs':
+ Matrix([ [t], [0]]), 'type_of_equation': 'type4'}
+ assert _classify_linear_system(eq1, funcs, t) == sol1
+
+ eq2 = [Eq(x1, t*x(t) + t*y(t) + t), Eq(y1, t*x(t) + t*y(t) + cos(t))]
+ sol2 = {'no_of_equation': 2, 'eq': [Eq(Derivative(x(t), t), t*x(t) + t*y(t) + t), Eq(Derivative(y(t), t),
+ t*x(t) + t*y(t) + cos(t))], 'func': [x(t), y(t)], 'order': {x(t): 1, y(t): 1}, 'is_linear': True,
+ 'is_homogeneous': False, 'is_general': True, 'rhs': Matrix([ [ t], [cos(t)]]), 'func_coeff':
+ Matrix([ [t, t], [t, t]]), 'is_constant': False, 'type_of_equation': 'type4',
+ 'commutative_antiderivative': Matrix([ [t**2/2, t**2/2], [t**2/2, t**2/2]])}
+ assert _classify_linear_system(eq2, funcs, t) == sol2
+
+ eq3 = [Eq(x1, t*(x(t) + y(t) + z(t) + 1)), Eq(y1, t*(x(t) + y(t) + z(t))), Eq(z1, t*(x(t) + y(t) + z(t)))]
+ sol3 = {'no_of_equation': 3, 'eq': [Eq(Derivative(x(t), t), t*(x(t) + y(t) + z(t) + 1)),
+ Eq(Derivative(y(t), t), t*(x(t) + y(t) + z(t))), Eq(Derivative(z(t), t), t*(x(t) + y(t) + z(t)))],
+ 'func': [x(t), y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True, 'is_constant':
+ False, 'is_homogeneous': False, 'is_general': True, 'func_coeff': -Matrix([ [-t, -t, -t], [-t, -t,
+ -t], [-t, -t, -t]]), 'commutative_antiderivative': Matrix([ [t**2/2, t**2/2, t**2/2], [t**2/2,
+ t**2/2, t**2/2], [t**2/2, t**2/2, t**2/2]]), 'rhs': Matrix([ [t], [0], [0]]), 'type_of_equation':
+ 'type4'}
+ assert _classify_linear_system(eq3, funcs_2[:-1], t) == sol3
+
+ eq4 = [Eq(x1, x(t) + y(t) + t*z(t) + 1), Eq(y1, x(t) + t*y(t) + z(t) + 10), Eq(z1, t*x(t) + y(t) + z(t) + t)]
+ sol4 = {'no_of_equation': 3, 'eq': [Eq(Derivative(x(t), t), t*z(t) + x(t) + y(t) + 1), Eq(Derivative(y(t),
+ t), t*y(t) + x(t) + z(t) + 10), Eq(Derivative(z(t), t), t*x(t) + t + y(t) + z(t))], 'func': [x(t),
+ y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True, 'is_constant': False,
+ 'is_homogeneous': False, 'is_general': True, 'func_coeff': -Matrix([ [-1, -1, -t], [-1, -t, -1], [-t,
+ -1, -1]]), 'commutative_antiderivative': Matrix([ [ t, t, t**2/2], [ t, t**2/2,
+ t], [t**2/2, t, t]]), 'rhs': Matrix([ [ 1], [10], [ t]]), 'type_of_equation': 'type4'}
+ assert _classify_linear_system(eq4, funcs_2[:-1], t) == sol4
+
+ sum_terms = t*(x(t) + y(t) + z(t) + w(t))
+ eq5 = [Eq(x1, sum_terms), Eq(y1, sum_terms), Eq(z1, sum_terms + 1), Eq(w1, sum_terms)]
+ sol5 = {'no_of_equation': 4, 'eq': [Eq(Derivative(x(t), t), t*(w(t) + x(t) + y(t) + z(t))),
+ Eq(Derivative(y(t), t), t*(w(t) + x(t) + y(t) + z(t))), Eq(Derivative(z(t), t), t*(w(t) + x(t) +
+ y(t) + z(t)) + 1), Eq(Derivative(w(t), t), t*(w(t) + x(t) + y(t) + z(t)))], 'func': [x(t), y(t),
+ z(t), w(t)], 'order': {x(t): 1, y(t): 1, z(t): 1, w(t): 1}, 'is_linear': True, 'is_constant': False,
+ 'is_homogeneous': False, 'is_general': True, 'func_coeff': -Matrix([ [-t, -t, -t, -t], [-t, -t, -t,
+ -t], [-t, -t, -t, -t], [-t, -t, -t, -t]]), 'commutative_antiderivative': Matrix([ [t**2/2, t**2/2,
+ t**2/2, t**2/2], [t**2/2, t**2/2, t**2/2, t**2/2], [t**2/2, t**2/2, t**2/2, t**2/2], [t**2/2,
+ t**2/2, t**2/2, t**2/2]]), 'rhs': Matrix([ [0], [0], [1], [0]]), 'type_of_equation': 'type4'}
+ assert _classify_linear_system(eq5, funcs_2, t) == sol5
+
+ # Second Order
+ t_ = symbols("t_")
+
+ eq1 = (Eq(9*x(t) + 7*y(t) + 4*Derivative(x(t), t) + Derivative(x(t), (t, 2)) + 3*Derivative(y(t), t), 11*exp(I*t)),
+ Eq(3*x(t) + 12*y(t) + 5*Derivative(x(t), t) + 8*Derivative(y(t), t) + Derivative(y(t), (t, 2)), 2*exp(I*t)))
+ sol1 = {'no_of_equation': 2, 'eq': (Eq(9*x(t) + 7*y(t) + 4*Derivative(x(t), t) + Derivative(x(t), (t, 2)) +
+ 3*Derivative(y(t), t), 11*exp(I*t)), Eq(3*x(t) + 12*y(t) + 5*Derivative(x(t), t) +
+ 8*Derivative(y(t), t) + Derivative(y(t), (t, 2)), 2*exp(I*t))), 'func': [x(t), y(t)], 'order':
+ {x(t): 2, y(t): 2}, 'is_linear': True, 'is_homogeneous': False, 'is_general': True, 'rhs': Matrix([
+ [11*exp(I*t)], [ 2*exp(I*t)]]), 'type_of_equation': 'type0', 'is_second_order': True,
+ 'is_higher_order': True}
+ assert _classify_linear_system(eq1, funcs, t) == sol1
+
+ eq2 = (Eq((4*t**2 + 7*t + 1)**2*Derivative(x(t), (t, 2)), 5*x(t) + 35*y(t)),
+ Eq((4*t**2 + 7*t + 1)**2*Derivative(y(t), (t, 2)), x(t) + 9*y(t)))
+ sol2 = {'no_of_equation': 2, 'eq': (Eq((4*t**2 + 7*t + 1)**2*Derivative(x(t), (t, 2)), 5*x(t) + 35*y(t)),
+ Eq((4*t**2 + 7*t + 1)**2*Derivative(y(t), (t, 2)), x(t) + 9*y(t))), 'func': [x(t), y(t)], 'order':
+ {x(t): 2, y(t): 2}, 'is_linear': True, 'is_homogeneous': True, 'is_general': True,
+ 'type_of_equation': 'type2', 'A0': Matrix([ [Rational(53, 4), 35], [ 1, Rational(69, 4)]]), 'g(t)': sqrt(4*t**2 + 7*t
+ + 1), 'tau': sqrt(33)*log(t - sqrt(33)/8 + Rational(7, 8))/33 - sqrt(33)*log(t + sqrt(33)/8 + Rational(7, 8))/33,
+ 'is_transformed': True, 't_': t_, 'is_second_order': True, 'is_higher_order': True}
+ assert _classify_linear_system(eq2, funcs, t) == sol2
+
+ eq3 = ((t*Derivative(x(t), t) - x(t))*log(t) + (t*Derivative(y(t), t) - y(t))*exp(t) + Derivative(x(t), (t, 2)),
+ t**2*(t*Derivative(x(t), t) - x(t)) + t*(t*Derivative(y(t), t) - y(t)) + Derivative(y(t), (t, 2)))
+ sol3 = {'no_of_equation': 2, 'eq': ((t*Derivative(x(t), t) - x(t))*log(t) + (t*Derivative(y(t), t) -
+ y(t))*exp(t) + Derivative(x(t), (t, 2)), t**2*(t*Derivative(x(t), t) - x(t)) + t*(t*Derivative(y(t),
+ t) - y(t)) + Derivative(y(t), (t, 2))), 'func': [x(t), y(t)], 'order': {x(t): 2, y(t): 2},
+ 'is_linear': True, 'is_homogeneous': True, 'is_general': True, 'type_of_equation': 'type1', 'A1':
+ Matrix([ [-t*log(t), -t*exp(t)], [ -t**3, -t**2]]), 'is_second_order': True,
+ 'is_higher_order': True}
+ assert _classify_linear_system(eq3, funcs, t) == sol3
+
+ eq4 = (Eq(x2, k*x(t) - l*y1), Eq(y2, l*x1 + k*y(t)))
+ sol4 = {'no_of_equation': 2, 'eq': (Eq(Derivative(x(t), (t, 2)), k*x(t) - l*Derivative(y(t), t)),
+ Eq(Derivative(y(t), (t, 2)), k*y(t) + l*Derivative(x(t), t))), 'func': [x(t), y(t)], 'order': {x(t):
+ 2, y(t): 2}, 'is_linear': True, 'is_homogeneous': True, 'is_general': True, 'type_of_equation':
+ 'type0', 'is_second_order': True, 'is_higher_order': True}
+ assert _classify_linear_system(eq4, funcs, t) == sol4
+
+
+ # Multiple matches
+
+ f, g = symbols("f g", cls=Function)
+ y, t_ = symbols("y t_")
+ funcs = [f(t), g(t)]
+
+ eq1 = [Eq(Derivative(f(t), t)**2 - 2*Derivative(f(t), t) + 1, 4),
+ Eq(-y*f(t) + Derivative(g(t), t), 0)]
+ sol1 = {'is_implicit': True,
+ 'canon_eqs': [[Eq(Derivative(f(t), t), -1), Eq(Derivative(g(t), t), y*f(t))],
+ [Eq(Derivative(f(t), t), 3), Eq(Derivative(g(t), t), y*f(t))]]}
+ assert _classify_linear_system(eq1, funcs, t) == sol1
+
+ raises(ValueError, lambda: _classify_linear_system(eq1, funcs[:1], t))
+
+ eq2 = [Eq(Derivative(f(t), t), (2*f(t) + g(t) + 1)/t), Eq(Derivative(g(t), t), (f(t) + 2*g(t))/t)]
+ sol2 = {'no_of_equation': 2, 'eq': [Eq(Derivative(f(t), t), (2*f(t) + g(t) + 1)/t), Eq(Derivative(g(t), t),
+ (f(t) + 2*g(t))/t)], 'func': [f(t), g(t)], 'order': {f(t): 1, g(t): 1}, 'is_linear': True,
+ 'is_homogeneous': False, 'is_general': True, 'rhs': Matrix([ [1], [0]]), 'func_coeff': Matrix([ [2,
+ 1], [1, 2]]), 'is_constant': False, 'type_of_equation': 'type6', 't_': t_, 'tau': log(t),
+ 'commutative_antiderivative': Matrix([ [2*log(t), log(t)], [ log(t), 2*log(t)]])}
+ assert _classify_linear_system(eq2, funcs, t) == sol2
+
+ eq3 = [Eq(Derivative(f(t), t), (2*f(t) + g(t))/t), Eq(Derivative(g(t), t), (f(t) + 2*g(t))/t)]
+ sol3 = {'no_of_equation': 2, 'eq': [Eq(Derivative(f(t), t), (2*f(t) + g(t))/t), Eq(Derivative(g(t), t),
+ (f(t) + 2*g(t))/t)], 'func': [f(t), g(t)], 'order': {f(t): 1, g(t): 1}, 'is_linear': True,
+ 'is_homogeneous': True, 'is_general': True, 'func_coeff': Matrix([ [2, 1], [1, 2]]), 'is_constant':
+ False, 'type_of_equation': 'type5', 't_': t_, 'rhs': Matrix([ [0], [0]]), 'tau': log(t),
+ 'commutative_antiderivative': Matrix([ [2*log(t), log(t)], [ log(t), 2*log(t)]])}
+ assert _classify_linear_system(eq3, funcs, t) == sol3
+
+
+def test_matrix_exp():
+ from sympy.matrices.dense import Matrix, eye, zeros
+ from sympy.solvers.ode.systems import matrix_exp
+ t = Symbol('t')
+
+ for n in range(1, 6+1):
+ assert matrix_exp(zeros(n), t) == eye(n)
+
+ for n in range(1, 6+1):
+ A = eye(n)
+ expAt = exp(t) * eye(n)
+ assert matrix_exp(A, t) == expAt
+
+ for n in range(1, 6+1):
+ A = Matrix(n, n, lambda i,j: i+1 if i==j else 0)
+ expAt = Matrix(n, n, lambda i,j: exp((i+1)*t) if i==j else 0)
+ assert matrix_exp(A, t) == expAt
+
+ A = Matrix([[0, 1], [-1, 0]])
+ expAt = Matrix([[cos(t), sin(t)], [-sin(t), cos(t)]])
+ assert matrix_exp(A, t) == expAt
+
+ A = Matrix([[2, -5], [2, -4]])
+ expAt = Matrix([
+ [3*exp(-t)*sin(t) + exp(-t)*cos(t), -5*exp(-t)*sin(t)],
+ [2*exp(-t)*sin(t), -3*exp(-t)*sin(t) + exp(-t)*cos(t)]
+ ])
+ assert matrix_exp(A, t) == expAt
+
+ A = Matrix([[21, 17, 6], [-5, -1, -6], [4, 4, 16]])
+ # TO update this.
+ # expAt = Matrix([
+ # [(8*t*exp(12*t) + 5*exp(12*t) - 1)*exp(4*t)/4,
+ # (8*t*exp(12*t) + 5*exp(12*t) - 5)*exp(4*t)/4,
+ # (exp(12*t) - 1)*exp(4*t)/2],
+ # [(-8*t*exp(12*t) - exp(12*t) + 1)*exp(4*t)/4,
+ # (-8*t*exp(12*t) - exp(12*t) + 5)*exp(4*t)/4,
+ # (-exp(12*t) + 1)*exp(4*t)/2],
+ # [4*t*exp(16*t), 4*t*exp(16*t), exp(16*t)]])
+ expAt = Matrix([
+ [2*t*exp(16*t) + 5*exp(16*t)/4 - exp(4*t)/4, 2*t*exp(16*t) + 5*exp(16*t)/4 - 5*exp(4*t)/4, exp(16*t)/2 - exp(4*t)/2],
+ [ -2*t*exp(16*t) - exp(16*t)/4 + exp(4*t)/4, -2*t*exp(16*t) - exp(16*t)/4 + 5*exp(4*t)/4, -exp(16*t)/2 + exp(4*t)/2],
+ [ 4*t*exp(16*t), 4*t*exp(16*t), exp(16*t)]
+ ])
+ assert matrix_exp(A, t) == expAt
+
+ A = Matrix([[1, 1, 0, 0],
+ [0, 1, 1, 0],
+ [0, 0, 1, -S(1)/8],
+ [0, 0, S(1)/2, S(1)/2]])
+ expAt = Matrix([
+ [exp(t), t*exp(t), 4*t*exp(3*t/4) + 8*t*exp(t) + 48*exp(3*t/4) - 48*exp(t),
+ -2*t*exp(3*t/4) - 2*t*exp(t) - 16*exp(3*t/4) + 16*exp(t)],
+ [0, exp(t), -t*exp(3*t/4) - 8*exp(3*t/4) + 8*exp(t), t*exp(3*t/4)/2 + 2*exp(3*t/4) - 2*exp(t)],
+ [0, 0, t*exp(3*t/4)/4 + exp(3*t/4), -t*exp(3*t/4)/8],
+ [0, 0, t*exp(3*t/4)/2, -t*exp(3*t/4)/4 + exp(3*t/4)]
+ ])
+ assert matrix_exp(A, t) == expAt
+
+ A = Matrix([
+ [ 0, 1, 0, 0],
+ [-1, 0, 0, 0],
+ [ 0, 0, 0, 1],
+ [ 0, 0, -1, 0]])
+
+ expAt = Matrix([
+ [ cos(t), sin(t), 0, 0],
+ [-sin(t), cos(t), 0, 0],
+ [ 0, 0, cos(t), sin(t)],
+ [ 0, 0, -sin(t), cos(t)]])
+ assert matrix_exp(A, t) == expAt
+
+ A = Matrix([
+ [ 0, 1, 1, 0],
+ [-1, 0, 0, 1],
+ [ 0, 0, 0, 1],
+ [ 0, 0, -1, 0]])
+
+ expAt = Matrix([
+ [ cos(t), sin(t), t*cos(t), t*sin(t)],
+ [-sin(t), cos(t), -t*sin(t), t*cos(t)],
+ [ 0, 0, cos(t), sin(t)],
+ [ 0, 0, -sin(t), cos(t)]])
+ assert matrix_exp(A, t) == expAt
+
+ # This case is unacceptably slow right now but should be solvable...
+ #a, b, c, d, e, f = symbols('a b c d e f')
+ #A = Matrix([
+ #[-a, b, c, d],
+ #[ a, -b, e, 0],
+ #[ 0, 0, -c - e - f, 0],
+ #[ 0, 0, f, -d]])
+
+ A = Matrix([[0, I], [I, 0]])
+ expAt = Matrix([
+ [exp(I*t)/2 + exp(-I*t)/2, exp(I*t)/2 - exp(-I*t)/2],
+ [exp(I*t)/2 - exp(-I*t)/2, exp(I*t)/2 + exp(-I*t)/2]])
+ assert matrix_exp(A, t) == expAt
+
+ # Testing Errors
+ M = Matrix([[1, 2, 3], [4, 5, 6], [7, 7, 7]])
+ M1 = Matrix([[t, 1], [1, 1]])
+
+ raises(ValueError, lambda: matrix_exp(M[:, :2], t))
+ raises(ValueError, lambda: matrix_exp(M[:2, :], t))
+ raises(ValueError, lambda: matrix_exp(M1, t))
+ raises(ValueError, lambda: matrix_exp(M1[:1, :1], t))
+
+
+def test_canonical_odes():
+ f, g, h = symbols('f g h', cls=Function)
+ x = symbols('x')
+ funcs = [f(x), g(x), h(x)]
+
+ eqs1 = [Eq(f(x).diff(x, x), f(x) + 2*g(x)), Eq(g(x) + 1, g(x).diff(x) + f(x))]
+ sol1 = [[Eq(Derivative(f(x), (x, 2)), f(x) + 2*g(x)), Eq(Derivative(g(x), x), -f(x) + g(x) + 1)]]
+ assert canonical_odes(eqs1, funcs[:2], x) == sol1
+
+ eqs2 = [Eq(f(x).diff(x), h(x).diff(x) + f(x)), Eq(g(x).diff(x)**2, f(x) + h(x)), Eq(h(x).diff(x), f(x))]
+ sol2 = [[Eq(Derivative(f(x), x), 2*f(x)), Eq(Derivative(g(x), x), -sqrt(f(x) + h(x))), Eq(Derivative(h(x), x), f(x))],
+ [Eq(Derivative(f(x), x), 2*f(x)), Eq(Derivative(g(x), x), sqrt(f(x) + h(x))), Eq(Derivative(h(x), x), f(x))]]
+ assert canonical_odes(eqs2, funcs, x) == sol2
+
+
+def test_sysode_linear_neq_order1_type1():
+
+ f, g, x, y, h = symbols('f g x y h', cls=Function)
+ a, b, c, t = symbols('a b c t')
+
+ eqs1 = [Eq(Derivative(x(t), t), x(t)),
+ Eq(Derivative(y(t), t), y(t))]
+ sol1 = [Eq(x(t), C1*exp(t)),
+ Eq(y(t), C2*exp(t))]
+ assert dsolve(eqs1) == sol1
+ assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+ eqs2 = [Eq(Derivative(x(t), t), 2*x(t)),
+ Eq(Derivative(y(t), t), 3*y(t))]
+ sol2 = [Eq(x(t), C1*exp(2*t)),
+ Eq(y(t), C2*exp(3*t))]
+ assert dsolve(eqs2) == sol2
+ assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+ eqs3 = [Eq(Derivative(x(t), t), a*x(t)),
+ Eq(Derivative(y(t), t), a*y(t))]
+ sol3 = [Eq(x(t), C1*exp(a*t)),
+ Eq(y(t), C2*exp(a*t))]
+ assert dsolve(eqs3) == sol3
+ assert checksysodesol(eqs3, sol3) == (True, [0, 0])
+
+ # Regression test case for issue #15474
+ # https://github.com/sympy/sympy/issues/15474
+ eqs4 = [Eq(Derivative(x(t), t), a*x(t)),
+ Eq(Derivative(y(t), t), b*y(t))]
+ sol4 = [Eq(x(t), C1*exp(a*t)),
+ Eq(y(t), C2*exp(b*t))]
+ assert dsolve(eqs4) == sol4
+ assert checksysodesol(eqs4, sol4) == (True, [0, 0])
+
+ eqs5 = [Eq(Derivative(x(t), t), -y(t)),
+ Eq(Derivative(y(t), t), x(t))]
+ sol5 = [Eq(x(t), -C1*sin(t) - C2*cos(t)),
+ Eq(y(t), C1*cos(t) - C2*sin(t))]
+ assert dsolve(eqs5) == sol5
+ assert checksysodesol(eqs5, sol5) == (True, [0, 0])
+
+ eqs6 = [Eq(Derivative(x(t), t), -2*y(t)),
+ Eq(Derivative(y(t), t), 2*x(t))]
+ sol6 = [Eq(x(t), -C1*sin(2*t) - C2*cos(2*t)),
+ Eq(y(t), C1*cos(2*t) - C2*sin(2*t))]
+ assert dsolve(eqs6) == sol6
+ assert checksysodesol(eqs6, sol6) == (True, [0, 0])
+
+ eqs7 = [Eq(Derivative(x(t), t), I*y(t)),
+ Eq(Derivative(y(t), t), I*x(t))]
+ sol7 = [Eq(x(t), -C1*exp(-I*t) + C2*exp(I*t)),
+ Eq(y(t), C1*exp(-I*t) + C2*exp(I*t))]
+ assert dsolve(eqs7) == sol7
+ assert checksysodesol(eqs7, sol7) == (True, [0, 0])
+
+ eqs8 = [Eq(Derivative(x(t), t), -a*y(t)),
+ Eq(Derivative(y(t), t), a*x(t))]
+ sol8 = [Eq(x(t), -I*C1*exp(-I*a*t) + I*C2*exp(I*a*t)),
+ Eq(y(t), C1*exp(-I*a*t) + C2*exp(I*a*t))]
+ assert dsolve(eqs8) == sol8
+ assert checksysodesol(eqs8, sol8) == (True, [0, 0])
+
+ eqs9 = [Eq(Derivative(x(t), t), x(t) + y(t)),
+ Eq(Derivative(y(t), t), x(t) - y(t))]
+ sol9 = [Eq(x(t), C1*(1 - sqrt(2))*exp(-sqrt(2)*t) + C2*(1 + sqrt(2))*exp(sqrt(2)*t)),
+ Eq(y(t), C1*exp(-sqrt(2)*t) + C2*exp(sqrt(2)*t))]
+ assert dsolve(eqs9) == sol9
+ assert checksysodesol(eqs9, sol9) == (True, [0, 0])
+
+ eqs10 = [Eq(Derivative(x(t), t), x(t) + y(t)),
+ Eq(Derivative(y(t), t), x(t) + y(t))]
+ sol10 = [Eq(x(t), -C1 + C2*exp(2*t)),
+ Eq(y(t), C1 + C2*exp(2*t))]
+ assert dsolve(eqs10) == sol10
+ assert checksysodesol(eqs10, sol10) == (True, [0, 0])
+
+ eqs11 = [Eq(Derivative(x(t), t), 2*x(t) + y(t)),
+ Eq(Derivative(y(t), t), -x(t) + 2*y(t))]
+ sol11 = [Eq(x(t), C1*exp(2*t)*sin(t) + C2*exp(2*t)*cos(t)),
+ Eq(y(t), C1*exp(2*t)*cos(t) - C2*exp(2*t)*sin(t))]
+ assert dsolve(eqs11) == sol11
+ assert checksysodesol(eqs11, sol11) == (True, [0, 0])
+
+ eqs12 = [Eq(Derivative(x(t), t), x(t) + 2*y(t)),
+ Eq(Derivative(y(t), t), 2*x(t) + y(t))]
+ sol12 = [Eq(x(t), -C1*exp(-t) + C2*exp(3*t)),
+ Eq(y(t), C1*exp(-t) + C2*exp(3*t))]
+ assert dsolve(eqs12) == sol12
+ assert checksysodesol(eqs12, sol12) == (True, [0, 0])
+
+ eqs13 = [Eq(Derivative(x(t), t), 4*x(t) + y(t)),
+ Eq(Derivative(y(t), t), -x(t) + 2*y(t))]
+ sol13 = [Eq(x(t), C2*t*exp(3*t) + (C1 + C2)*exp(3*t)),
+ Eq(y(t), -C1*exp(3*t) - C2*t*exp(3*t))]
+ assert dsolve(eqs13) == sol13
+ assert checksysodesol(eqs13, sol13) == (True, [0, 0])
+
+ eqs14 = [Eq(Derivative(x(t), t), a*y(t)),
+ Eq(Derivative(y(t), t), a*x(t))]
+ sol14 = [Eq(x(t), -C1*exp(-a*t) + C2*exp(a*t)),
+ Eq(y(t), C1*exp(-a*t) + C2*exp(a*t))]
+ assert dsolve(eqs14) == sol14
+ assert checksysodesol(eqs14, sol14) == (True, [0, 0])
+
+ eqs15 = [Eq(Derivative(x(t), t), a*y(t)),
+ Eq(Derivative(y(t), t), b*x(t))]
+ sol15 = [Eq(x(t), -C1*a*exp(-t*sqrt(a*b))/sqrt(a*b) + C2*a*exp(t*sqrt(a*b))/sqrt(a*b)),
+ Eq(y(t), C1*exp(-t*sqrt(a*b)) + C2*exp(t*sqrt(a*b)))]
+ assert dsolve(eqs15) == sol15
+ assert checksysodesol(eqs15, sol15) == (True, [0, 0])
+
+ eqs16 = [Eq(Derivative(x(t), t), a*x(t) + b*y(t)),
+ Eq(Derivative(y(t), t), c*x(t))]
+ sol16 = [Eq(x(t), -2*C1*b*exp(t*(a + sqrt(a**2 + 4*b*c))/2)/(a - sqrt(a**2 + 4*b*c)) - 2*C2*b*exp(t*(a -
+ sqrt(a**2 + 4*b*c))/2)/(a + sqrt(a**2 + 4*b*c))),
+ Eq(y(t), C1*exp(t*(a + sqrt(a**2 + 4*b*c))/2) + C2*exp(t*(a - sqrt(a**2 + 4*b*c))/2))]
+ assert dsolve(eqs16) == sol16
+ assert checksysodesol(eqs16, sol16) == (True, [0, 0])
+
+ # Regression test case for issue #18562
+ # https://github.com/sympy/sympy/issues/18562
+ eqs17 = [Eq(Derivative(x(t), t), a*y(t) + x(t)),
+ Eq(Derivative(y(t), t), a*x(t) - y(t))]
+ sol17 = [Eq(x(t), C1*a*exp(t*sqrt(a**2 + 1))/(sqrt(a**2 + 1) - 1) - C2*a*exp(-t*sqrt(a**2 + 1))/(sqrt(a**2 +
+ 1) + 1)),
+ Eq(y(t), C1*exp(t*sqrt(a**2 + 1)) + C2*exp(-t*sqrt(a**2 + 1)))]
+ assert dsolve(eqs17) == sol17
+ assert checksysodesol(eqs17, sol17) == (True, [0, 0])
+
+ eqs18 = [Eq(Derivative(x(t), t), 0),
+ Eq(Derivative(y(t), t), 0)]
+ sol18 = [Eq(x(t), C1),
+ Eq(y(t), C2)]
+ assert dsolve(eqs18) == sol18
+ assert checksysodesol(eqs18, sol18) == (True, [0, 0])
+
+ eqs19 = [Eq(Derivative(x(t), t), 2*x(t) - y(t)),
+ Eq(Derivative(y(t), t), x(t))]
+ sol19 = [Eq(x(t), C2*t*exp(t) + (C1 + C2)*exp(t)),
+ Eq(y(t), C1*exp(t) + C2*t*exp(t))]
+ assert dsolve(eqs19) == sol19
+ assert checksysodesol(eqs19, sol19) == (True, [0, 0])
+
+ eqs20 = [Eq(Derivative(x(t), t), x(t)),
+ Eq(Derivative(y(t), t), x(t) + y(t))]
+ sol20 = [Eq(x(t), C1*exp(t)),
+ Eq(y(t), C1*t*exp(t) + C2*exp(t))]
+ assert dsolve(eqs20) == sol20
+ assert checksysodesol(eqs20, sol20) == (True, [0, 0])
+
+ eqs21 = [Eq(Derivative(x(t), t), 3*x(t)),
+ Eq(Derivative(y(t), t), x(t) + y(t))]
+ sol21 = [Eq(x(t), 2*C1*exp(3*t)),
+ Eq(y(t), C1*exp(3*t) + C2*exp(t))]
+ assert dsolve(eqs21) == sol21
+ assert checksysodesol(eqs21, sol21) == (True, [0, 0])
+
+ eqs22 = [Eq(Derivative(x(t), t), 3*x(t)),
+ Eq(Derivative(y(t), t), y(t))]
+ sol22 = [Eq(x(t), C1*exp(3*t)),
+ Eq(y(t), C2*exp(t))]
+ assert dsolve(eqs22) == sol22
+ assert checksysodesol(eqs22, sol22) == (True, [0, 0])
+
+
+@slow
+def test_sysode_linear_neq_order1_type1_slow():
+
+ t = Symbol('t')
+ Z0 = Function('Z0')
+ Z1 = Function('Z1')
+ Z2 = Function('Z2')
+ Z3 = Function('Z3')
+
+ k01, k10, k20, k21, k23, k30 = symbols('k01 k10 k20 k21 k23 k30')
+
+ eqs1 = [Eq(Derivative(Z0(t), t), -k01*Z0(t) + k10*Z1(t) + k20*Z2(t) + k30*Z3(t)),
+ Eq(Derivative(Z1(t), t), k01*Z0(t) - k10*Z1(t) + k21*Z2(t)),
+ Eq(Derivative(Z2(t), t), (-k20 - k21 - k23)*Z2(t)),
+ Eq(Derivative(Z3(t), t), k23*Z2(t) - k30*Z3(t))]
+ sol1 = [Eq(Z0(t), C1*k10/k01 - C2*(k10 - k30)*exp(-k30*t)/(k01 + k10 - k30) - C3*(k10*(k20 + k21 - k30) -
+ k20**2 - k20*(k21 + k23 - k30) + k23*k30)*exp(-t*(k20 + k21 + k23))/(k23*(-k01 - k10 + k20 + k21 +
+ k23)) - C4*exp(-t*(k01 + k10))),
+ Eq(Z1(t), C1 - C2*k01*exp(-k30*t)/(k01 + k10 - k30) + C3*(-k01*(k20 + k21 - k30) + k20*k21 + k21**2
+ + k21*(k23 - k30))*exp(-t*(k20 + k21 + k23))/(k23*(-k01 - k10 + k20 + k21 + k23)) + C4*exp(-t*(k01 +
+ k10))),
+ Eq(Z2(t), -C3*(k20 + k21 + k23 - k30)*exp(-t*(k20 + k21 + k23))/k23),
+ Eq(Z3(t), C2*exp(-k30*t) + C3*exp(-t*(k20 + k21 + k23)))]
+ assert dsolve(eqs1) == sol1
+ assert checksysodesol(eqs1, sol1) == (True, [0, 0, 0, 0])
+
+ x, y, z, u, v, w = symbols('x y z u v w', cls=Function)
+ k2, k3 = symbols('k2 k3')
+ a_b, a_c = symbols('a_b a_c', real=True)
+
+ eqs2 = [Eq(Derivative(z(t), t), k2*y(t)),
+ Eq(Derivative(x(t), t), k3*y(t)),
+ Eq(Derivative(y(t), t), (-k2 - k3)*y(t))]
+ sol2 = [Eq(z(t), C1 - C2*k2*exp(-t*(k2 + k3))/(k2 + k3)),
+ Eq(x(t), -C2*k3*exp(-t*(k2 + k3))/(k2 + k3) + C3),
+ Eq(y(t), C2*exp(-t*(k2 + k3)))]
+ assert dsolve(eqs2) == sol2
+ assert checksysodesol(eqs2, sol2) == (True, [0, 0, 0])
+
+ eqs3 = [4*u(t) - v(t) - 2*w(t) + Derivative(u(t), t),
+ 2*u(t) + v(t) - 2*w(t) + Derivative(v(t), t),
+ 5*u(t) + v(t) - 3*w(t) + Derivative(w(t), t)]
+ sol3 = [Eq(u(t), C3*exp(-2*t) + (C1/2 + sqrt(3)*C2/6)*cos(sqrt(3)*t) + sin(sqrt(3)*t)*(sqrt(3)*C1/6 +
+ C2*Rational(-1, 2))),
+ Eq(v(t), (C1/2 + sqrt(3)*C2/6)*cos(sqrt(3)*t) + sin(sqrt(3)*t)*(sqrt(3)*C1/6 + C2*Rational(-1, 2))),
+ Eq(w(t), C1*cos(sqrt(3)*t) - C2*sin(sqrt(3)*t) + C3*exp(-2*t))]
+ assert dsolve(eqs3) == sol3
+ assert checksysodesol(eqs3, sol3) == (True, [0, 0, 0])
+
+ eqs4 = [Eq(Derivative(x(t), t), w(t)*Rational(-2, 9) + 2*x(t) + y(t) + z(t)*Rational(-8, 9)),
+ Eq(Derivative(y(t), t), w(t)*Rational(4, 9) + 2*y(t) + z(t)*Rational(16, 9)),
+ Eq(Derivative(z(t), t), w(t)*Rational(-2, 9) + z(t)*Rational(37, 9)),
+ Eq(Derivative(w(t), t), w(t)*Rational(44, 9) + z(t)*Rational(-4, 9))]
+ sol4 = [Eq(x(t), C1*exp(2*t) + C2*t*exp(2*t)),
+ Eq(y(t), C2*exp(2*t) + 2*C3*exp(4*t)),
+ Eq(z(t), 2*C3*exp(4*t) + C4*exp(5*t)*Rational(-1, 4)),
+ Eq(w(t), C3*exp(4*t) + C4*exp(5*t))]
+ assert dsolve(eqs4) == sol4
+ assert checksysodesol(eqs4, sol4) == (True, [0, 0, 0, 0])
+
+ # Regression test case for issue #15574
+ # https://github.com/sympy/sympy/issues/15574
+ eq5 = [Eq(x(t).diff(t), x(t)), Eq(y(t).diff(t), y(t)), Eq(z(t).diff(t), z(t)), Eq(w(t).diff(t), w(t))]
+ sol5 = [Eq(x(t), C1*exp(t)), Eq(y(t), C2*exp(t)), Eq(z(t), C3*exp(t)), Eq(w(t), C4*exp(t))]
+ assert dsolve(eq5) == sol5
+ assert checksysodesol(eq5, sol5) == (True, [0, 0, 0, 0])
+
+ eqs6 = [Eq(Derivative(x(t), t), x(t) + y(t)),
+ Eq(Derivative(y(t), t), y(t) + z(t)),
+ Eq(Derivative(z(t), t), w(t)*Rational(-1, 8) + z(t)),
+ Eq(Derivative(w(t), t), w(t)/2 + z(t)/2)]
+ sol6 = [Eq(x(t), C1*exp(t) + C2*t*exp(t) + 4*C4*t*exp(t*Rational(3, 4)) + (4*C3 + 48*C4)*exp(t*Rational(3,
+ 4))),
+ Eq(y(t), C2*exp(t) - C4*t*exp(t*Rational(3, 4)) - (C3 + 8*C4)*exp(t*Rational(3, 4))),
+ Eq(z(t), C4*t*exp(t*Rational(3, 4))/4 + (C3/4 + C4)*exp(t*Rational(3, 4))),
+ Eq(w(t), C3*exp(t*Rational(3, 4))/2 + C4*t*exp(t*Rational(3, 4))/2)]
+ assert dsolve(eqs6) == sol6
+ assert checksysodesol(eqs6, sol6) == (True, [0, 0, 0, 0])
+
+ # Regression test case for issue #15574
+ # https://github.com/sympy/sympy/issues/15574
+ eq7 = [Eq(Derivative(x(t), t), x(t)), Eq(Derivative(y(t), t), y(t)), Eq(Derivative(z(t), t), z(t)),
+ Eq(Derivative(w(t), t), w(t)), Eq(Derivative(u(t), t), u(t))]
+ sol7 = [Eq(x(t), C1*exp(t)), Eq(y(t), C2*exp(t)), Eq(z(t), C3*exp(t)), Eq(w(t), C4*exp(t)),
+ Eq(u(t), C5*exp(t))]
+ assert dsolve(eq7) == sol7
+ assert checksysodesol(eq7, sol7) == (True, [0, 0, 0, 0, 0])
+
+ eqs8 = [Eq(Derivative(x(t), t), 2*x(t) + y(t)),
+ Eq(Derivative(y(t), t), 2*y(t)),
+ Eq(Derivative(z(t), t), 4*z(t)),
+ Eq(Derivative(w(t), t), u(t) + 5*w(t)),
+ Eq(Derivative(u(t), t), 5*u(t))]
+ sol8 = [Eq(x(t), C1*exp(2*t) + C2*t*exp(2*t)),
+ Eq(y(t), C2*exp(2*t)),
+ Eq(z(t), C3*exp(4*t)),
+ Eq(w(t), C4*exp(5*t) + C5*t*exp(5*t)),
+ Eq(u(t), C5*exp(5*t))]
+ assert dsolve(eqs8) == sol8
+ assert checksysodesol(eqs8, sol8) == (True, [0, 0, 0, 0, 0])
+
+ # Regression test case for issue #15574
+ # https://github.com/sympy/sympy/issues/15574
+ eq9 = [Eq(Derivative(x(t), t), x(t)), Eq(Derivative(y(t), t), y(t)), Eq(Derivative(z(t), t), z(t))]
+ sol9 = [Eq(x(t), C1*exp(t)), Eq(y(t), C2*exp(t)), Eq(z(t), C3*exp(t))]
+ assert dsolve(eq9) == sol9
+ assert checksysodesol(eq9, sol9) == (True, [0, 0, 0])
+
+ # Regression test case for issue #15407
+ # https://github.com/sympy/sympy/issues/15407
+ eqs10 = [Eq(Derivative(x(t), t), (-a_b - a_c)*x(t)),
+ Eq(Derivative(y(t), t), a_b*y(t)),
+ Eq(Derivative(z(t), t), a_c*x(t))]
+ sol10 = [Eq(x(t), -C1*(a_b + a_c)*exp(-t*(a_b + a_c))/a_c),
+ Eq(y(t), C2*exp(a_b*t)),
+ Eq(z(t), C1*exp(-t*(a_b + a_c)) + C3)]
+ assert dsolve(eqs10) == sol10
+ assert checksysodesol(eqs10, sol10) == (True, [0, 0, 0])
+
+ # Regression test case for issue #14312
+ # https://github.com/sympy/sympy/issues/14312
+ eqs11 = [Eq(Derivative(x(t), t), k3*y(t)),
+ Eq(Derivative(y(t), t), (-k2 - k3)*y(t)),
+ Eq(Derivative(z(t), t), k2*y(t))]
+ sol11 = [Eq(x(t), C1 + C2*k3*exp(-t*(k2 + k3))/k2),
+ Eq(y(t), -C2*(k2 + k3)*exp(-t*(k2 + k3))/k2),
+ Eq(z(t), C2*exp(-t*(k2 + k3)) + C3)]
+ assert dsolve(eqs11) == sol11
+ assert checksysodesol(eqs11, sol11) == (True, [0, 0, 0])
+
+ # Regression test case for issue #14312
+ # https://github.com/sympy/sympy/issues/14312
+ eqs12 = [Eq(Derivative(z(t), t), k2*y(t)),
+ Eq(Derivative(x(t), t), k3*y(t)),
+ Eq(Derivative(y(t), t), (-k2 - k3)*y(t))]
+ sol12 = [Eq(z(t), C1 - C2*k2*exp(-t*(k2 + k3))/(k2 + k3)),
+ Eq(x(t), -C2*k3*exp(-t*(k2 + k3))/(k2 + k3) + C3),
+ Eq(y(t), C2*exp(-t*(k2 + k3)))]
+ assert dsolve(eqs12) == sol12
+ assert checksysodesol(eqs12, sol12) == (True, [0, 0, 0])
+
+ f, g, h = symbols('f, g, h', cls=Function)
+ a, b, c = symbols('a, b, c')
+
+ # Regression test case for issue #15474
+ # https://github.com/sympy/sympy/issues/15474
+ eqs13 = [Eq(Derivative(f(t), t), 2*f(t) + g(t)),
+ Eq(Derivative(g(t), t), a*f(t))]
+ sol13 = [Eq(f(t), C1*exp(t*(sqrt(a + 1) + 1))/(sqrt(a + 1) - 1) - C2*exp(-t*(sqrt(a + 1) - 1))/(sqrt(a + 1) +
+ 1)),
+ Eq(g(t), C1*exp(t*(sqrt(a + 1) + 1)) + C2*exp(-t*(sqrt(a + 1) - 1)))]
+ assert dsolve(eqs13) == sol13
+ assert checksysodesol(eqs13, sol13) == (True, [0, 0])
+
+ eqs14 = [Eq(Derivative(f(t), t), 2*g(t) - 3*h(t)),
+ Eq(Derivative(g(t), t), -2*f(t) + 4*h(t)),
+ Eq(Derivative(h(t), t), 3*f(t) - 4*g(t))]
+ sol14 = [Eq(f(t), 2*C1 - sin(sqrt(29)*t)*(sqrt(29)*C2*Rational(3, 25) + C3*Rational(-8, 25)) -
+ cos(sqrt(29)*t)*(C2*Rational(8, 25) + sqrt(29)*C3*Rational(3, 25))),
+ Eq(g(t), C1*Rational(3, 2) + sin(sqrt(29)*t)*(sqrt(29)*C2*Rational(4, 25) + C3*Rational(6, 25)) -
+ cos(sqrt(29)*t)*(C2*Rational(6, 25) + sqrt(29)*C3*Rational(-4, 25))),
+ Eq(h(t), C1 + C2*cos(sqrt(29)*t) - C3*sin(sqrt(29)*t))]
+ assert dsolve(eqs14) == sol14
+ assert checksysodesol(eqs14, sol14) == (True, [0, 0, 0])
+
+ eqs15 = [Eq(2*Derivative(f(t), t), 12*g(t) - 12*h(t)),
+ Eq(3*Derivative(g(t), t), -8*f(t) + 8*h(t)),
+ Eq(4*Derivative(h(t), t), 6*f(t) - 6*g(t))]
+ sol15 = [Eq(f(t), C1 - sin(sqrt(29)*t)*(sqrt(29)*C2*Rational(6, 13) + C3*Rational(-16, 13)) -
+ cos(sqrt(29)*t)*(C2*Rational(16, 13) + sqrt(29)*C3*Rational(6, 13))),
+ Eq(g(t), C1 + sin(sqrt(29)*t)*(sqrt(29)*C2*Rational(8, 39) + C3*Rational(16, 13)) -
+ cos(sqrt(29)*t)*(C2*Rational(16, 13) + sqrt(29)*C3*Rational(-8, 39))),
+ Eq(h(t), C1 + C2*cos(sqrt(29)*t) - C3*sin(sqrt(29)*t))]
+ assert dsolve(eqs15) == sol15
+ assert checksysodesol(eqs15, sol15) == (True, [0, 0, 0])
+
+ eq16 = (Eq(diff(x(t), t), 21*x(t)), Eq(diff(y(t), t), 17*x(t) + 3*y(t)),
+ Eq(diff(z(t), t), 5*x(t) + 7*y(t) + 9*z(t)))
+ sol16 = [Eq(x(t), 216*C1*exp(21*t)/209),
+ Eq(y(t), 204*C1*exp(21*t)/209 - 6*C2*exp(3*t)/7),
+ Eq(z(t), C1*exp(21*t) + C2*exp(3*t) + C3*exp(9*t))]
+ assert dsolve(eq16) == sol16
+ assert checksysodesol(eq16, sol16) == (True, [0, 0, 0])
+
+ eqs17 = [Eq(Derivative(x(t), t), 3*y(t) - 11*z(t)),
+ Eq(Derivative(y(t), t), -3*x(t) + 7*z(t)),
+ Eq(Derivative(z(t), t), 11*x(t) - 7*y(t))]
+ sol17 = [Eq(x(t), C1*Rational(7, 3) - sin(sqrt(179)*t)*(sqrt(179)*C2*Rational(11, 170) + C3*Rational(-21,
+ 170)) - cos(sqrt(179)*t)*(C2*Rational(21, 170) + sqrt(179)*C3*Rational(11, 170))),
+ Eq(y(t), C1*Rational(11, 3) + sin(sqrt(179)*t)*(sqrt(179)*C2*Rational(7, 170) + C3*Rational(33,
+ 170)) - cos(sqrt(179)*t)*(C2*Rational(33, 170) + sqrt(179)*C3*Rational(-7, 170))),
+ Eq(z(t), C1 + C2*cos(sqrt(179)*t) - C3*sin(sqrt(179)*t))]
+ assert dsolve(eqs17) == sol17
+ assert checksysodesol(eqs17, sol17) == (True, [0, 0, 0])
+
+ eqs18 = [Eq(3*Derivative(x(t), t), 20*y(t) - 20*z(t)),
+ Eq(4*Derivative(y(t), t), -15*x(t) + 15*z(t)),
+ Eq(5*Derivative(z(t), t), 12*x(t) - 12*y(t))]
+ sol18 = [Eq(x(t), C1 - sin(5*sqrt(2)*t)*(sqrt(2)*C2*Rational(4, 3) - C3) - cos(5*sqrt(2)*t)*(C2 +
+ sqrt(2)*C3*Rational(4, 3))),
+ Eq(y(t), C1 + sin(5*sqrt(2)*t)*(sqrt(2)*C2*Rational(3, 4) + C3) - cos(5*sqrt(2)*t)*(C2 +
+ sqrt(2)*C3*Rational(-3, 4))),
+ Eq(z(t), C1 + C2*cos(5*sqrt(2)*t) - C3*sin(5*sqrt(2)*t))]
+ assert dsolve(eqs18) == sol18
+ assert checksysodesol(eqs18, sol18) == (True, [0, 0, 0])
+
+ eqs19 = [Eq(Derivative(x(t), t), 4*x(t) - z(t)),
+ Eq(Derivative(y(t), t), 2*x(t) + 2*y(t) - z(t)),
+ Eq(Derivative(z(t), t), 3*x(t) + y(t))]
+ sol19 = [Eq(x(t), C2*t**2*exp(2*t)/2 + t*(2*C2 + C3)*exp(2*t) + (C1 + C2 + 2*C3)*exp(2*t)),
+ Eq(y(t), C2*t**2*exp(2*t)/2 + t*(2*C2 + C3)*exp(2*t) + (C1 + 2*C3)*exp(2*t)),
+ Eq(z(t), C2*t**2*exp(2*t) + t*(3*C2 + 2*C3)*exp(2*t) + (2*C1 + 3*C3)*exp(2*t))]
+ assert dsolve(eqs19) == sol19
+ assert checksysodesol(eqs19, sol19) == (True, [0, 0, 0])
+
+ eqs20 = [Eq(Derivative(x(t), t), 4*x(t) - y(t) - 2*z(t)),
+ Eq(Derivative(y(t), t), 2*x(t) + y(t) - 2*z(t)),
+ Eq(Derivative(z(t), t), 5*x(t) - 3*z(t))]
+ sol20 = [Eq(x(t), C1*exp(2*t) - sin(t)*(C2*Rational(3, 5) + C3/5) - cos(t)*(C2/5 + C3*Rational(-3, 5))),
+ Eq(y(t), -sin(t)*(C2*Rational(3, 5) + C3/5) - cos(t)*(C2/5 + C3*Rational(-3, 5))),
+ Eq(z(t), C1*exp(2*t) - C2*sin(t) + C3*cos(t))]
+ assert dsolve(eqs20) == sol20
+ assert checksysodesol(eqs20, sol20) == (True, [0, 0, 0])
+
+ eq21 = (Eq(diff(x(t), t), 9*y(t)), Eq(diff(y(t), t), 12*x(t)))
+ sol21 = [Eq(x(t), -sqrt(3)*C1*exp(-6*sqrt(3)*t)/2 + sqrt(3)*C2*exp(6*sqrt(3)*t)/2),
+ Eq(y(t), C1*exp(-6*sqrt(3)*t) + C2*exp(6*sqrt(3)*t))]
+
+ assert dsolve(eq21) == sol21
+ assert checksysodesol(eq21, sol21) == (True, [0, 0])
+
+ eqs22 = [Eq(Derivative(x(t), t), 2*x(t) + 4*y(t)),
+ Eq(Derivative(y(t), t), 12*x(t) + 41*y(t))]
+ sol22 = [Eq(x(t), C1*(39 - sqrt(1713))*exp(t*(sqrt(1713) + 43)/2)*Rational(-1, 24) + C2*(39 +
+ sqrt(1713))*exp(t*(43 - sqrt(1713))/2)*Rational(-1, 24)),
+ Eq(y(t), C1*exp(t*(sqrt(1713) + 43)/2) + C2*exp(t*(43 - sqrt(1713))/2))]
+ assert dsolve(eqs22) == sol22
+ assert checksysodesol(eqs22, sol22) == (True, [0, 0])
+
+ eqs23 = [Eq(Derivative(x(t), t), x(t) + y(t)),
+ Eq(Derivative(y(t), t), -2*x(t) + 2*y(t))]
+ sol23 = [Eq(x(t), (C1/4 + sqrt(7)*C2/4)*cos(sqrt(7)*t/2)*exp(t*Rational(3, 2)) +
+ sin(sqrt(7)*t/2)*(sqrt(7)*C1/4 + C2*Rational(-1, 4))*exp(t*Rational(3, 2))),
+ Eq(y(t), C1*cos(sqrt(7)*t/2)*exp(t*Rational(3, 2)) - C2*sin(sqrt(7)*t/2)*exp(t*Rational(3, 2)))]
+ assert dsolve(eqs23) == sol23
+ assert checksysodesol(eqs23, sol23) == (True, [0, 0])
+
+ # Regression test case for issue #15474
+ # https://github.com/sympy/sympy/issues/15474
+ a = Symbol("a", real=True)
+ eq24 = [x(t).diff(t) - a*y(t), y(t).diff(t) + a*x(t)]
+ sol24 = [Eq(x(t), C1*sin(a*t) + C2*cos(a*t)), Eq(y(t), C1*cos(a*t) - C2*sin(a*t))]
+ assert dsolve(eq24) == sol24
+ assert checksysodesol(eq24, sol24) == (True, [0, 0])
+
+ # Regression test case for issue #19150
+ # https://github.com/sympy/sympy/issues/19150
+ eqs25 = [Eq(Derivative(f(t), t), 0),
+ Eq(Derivative(g(t), t), (f(t) - 2*g(t) + x(t))/(b*c)),
+ Eq(Derivative(x(t), t), (g(t) - 2*x(t) + y(t))/(b*c)),
+ Eq(Derivative(y(t), t), (h(t) + x(t) - 2*y(t))/(b*c)),
+ Eq(Derivative(h(t), t), 0)]
+ sol25 = [Eq(f(t), -3*C1 + 4*C2),
+ Eq(g(t), -2*C1 + 3*C2 - C3*exp(-2*t/(b*c)) + C4*exp(-t*(sqrt(2) + 2)/(b*c)) + C5*exp(-t*(2 -
+ sqrt(2))/(b*c))),
+ Eq(x(t), -C1 + 2*C2 - sqrt(2)*C4*exp(-t*(sqrt(2) + 2)/(b*c)) + sqrt(2)*C5*exp(-t*(2 -
+ sqrt(2))/(b*c))),
+ Eq(y(t), C2 + C3*exp(-2*t/(b*c)) + C4*exp(-t*(sqrt(2) + 2)/(b*c)) + C5*exp(-t*(2 - sqrt(2))/(b*c))),
+ Eq(h(t), C1)]
+ assert dsolve(eqs25) == sol25
+ assert checksysodesol(eqs25, sol25) == (True, [0, 0, 0, 0, 0])
+
+ eq26 = [Eq(Derivative(f(t), t), 2*f(t)), Eq(Derivative(g(t), t), 3*f(t) + 7*g(t))]
+ sol26 = [Eq(f(t), -5*C1*exp(2*t)/3), Eq(g(t), C1*exp(2*t) + C2*exp(7*t))]
+ assert dsolve(eq26) == sol26
+ assert checksysodesol(eq26, sol26) == (True, [0, 0])
+
+ eq27 = [Eq(Derivative(f(t), t), -9*I*f(t) - 4*g(t)), Eq(Derivative(g(t), t), -4*I*g(t))]
+ sol27 = [Eq(f(t), 4*I*C1*exp(-4*I*t)/5 + C2*exp(-9*I*t)), Eq(g(t), C1*exp(-4*I*t))]
+ assert dsolve(eq27) == sol27
+ assert checksysodesol(eq27, sol27) == (True, [0, 0])
+
+ eq28 = [Eq(Derivative(f(t), t), -9*I*f(t)), Eq(Derivative(g(t), t), -4*I*g(t))]
+ sol28 = [Eq(f(t), C1*exp(-9*I*t)), Eq(g(t), C2*exp(-4*I*t))]
+ assert dsolve(eq28) == sol28
+ assert checksysodesol(eq28, sol28) == (True, [0, 0])
+
+ eq29 = [Eq(Derivative(f(t), t), 0), Eq(Derivative(g(t), t), 0)]
+ sol29 = [Eq(f(t), C1), Eq(g(t), C2)]
+ assert dsolve(eq29) == sol29
+ assert checksysodesol(eq29, sol29) == (True, [0, 0])
+
+ eq30 = [Eq(Derivative(f(t), t), f(t)), Eq(Derivative(g(t), t), 0)]
+ sol30 = [Eq(f(t), C1*exp(t)), Eq(g(t), C2)]
+ assert dsolve(eq30) == sol30
+ assert checksysodesol(eq30, sol30) == (True, [0, 0])
+
+ eq31 = [Eq(Derivative(f(t), t), g(t)), Eq(Derivative(g(t), t), 0)]
+ sol31 = [Eq(f(t), C1 + C2*t), Eq(g(t), C2)]
+ assert dsolve(eq31) == sol31
+ assert checksysodesol(eq31, sol31) == (True, [0, 0])
+
+ eq32 = [Eq(Derivative(f(t), t), 0), Eq(Derivative(g(t), t), f(t))]
+ sol32 = [Eq(f(t), C1), Eq(g(t), C1*t + C2)]
+ assert dsolve(eq32) == sol32
+ assert checksysodesol(eq32, sol32) == (True, [0, 0])
+
+ eq33 = [Eq(Derivative(f(t), t), 0), Eq(Derivative(g(t), t), g(t))]
+ sol33 = [Eq(f(t), C1), Eq(g(t), C2*exp(t))]
+ assert dsolve(eq33) == sol33
+ assert checksysodesol(eq33, sol33) == (True, [0, 0])
+
+ eq34 = [Eq(Derivative(f(t), t), f(t)), Eq(Derivative(g(t), t), I*g(t))]
+ sol34 = [Eq(f(t), C1*exp(t)), Eq(g(t), C2*exp(I*t))]
+ assert dsolve(eq34) == sol34
+ assert checksysodesol(eq34, sol34) == (True, [0, 0])
+
+ eq35 = [Eq(Derivative(f(t), t), I*f(t)), Eq(Derivative(g(t), t), -I*g(t))]
+ sol35 = [Eq(f(t), C1*exp(I*t)), Eq(g(t), C2*exp(-I*t))]
+ assert dsolve(eq35) == sol35
+ assert checksysodesol(eq35, sol35) == (True, [0, 0])
+
+ eq36 = [Eq(Derivative(f(t), t), I*g(t)), Eq(Derivative(g(t), t), 0)]
+ sol36 = [Eq(f(t), I*C1 + I*C2*t), Eq(g(t), C2)]
+ assert dsolve(eq36) == sol36
+ assert checksysodesol(eq36, sol36) == (True, [0, 0])
+
+ eq37 = [Eq(Derivative(f(t), t), I*g(t)), Eq(Derivative(g(t), t), I*f(t))]
+ sol37 = [Eq(f(t), -C1*exp(-I*t) + C2*exp(I*t)), Eq(g(t), C1*exp(-I*t) + C2*exp(I*t))]
+ assert dsolve(eq37) == sol37
+ assert checksysodesol(eq37, sol37) == (True, [0, 0])
+
+ # Multiple systems
+ eq1 = [Eq(Derivative(f(t), t)**2, g(t)**2), Eq(-f(t) + Derivative(g(t), t), 0)]
+ sol1 = [[Eq(f(t), -C1*sin(t) - C2*cos(t)),
+ Eq(g(t), C1*cos(t) - C2*sin(t))],
+ [Eq(f(t), -C1*exp(-t) + C2*exp(t)),
+ Eq(g(t), C1*exp(-t) + C2*exp(t))]]
+ assert dsolve(eq1) == sol1
+ for sol in sol1:
+ assert checksysodesol(eq1, sol) == (True, [0, 0])
+
+
+def test_sysode_linear_neq_order1_type2():
+
+ f, g, h, k = symbols('f g h k', cls=Function)
+ x, t, a, b, c, d, y = symbols('x t a b c d y')
+ k1, k2 = symbols('k1 k2')
+
+
+ eqs1 = [Eq(Derivative(f(x), x), f(x) + g(x) + 5),
+ Eq(Derivative(g(x), x), -f(x) - g(x) + 7)]
+ sol1 = [Eq(f(x), C1 + C2 + 6*x**2 + x*(C2 + 5)),
+ Eq(g(x), -C1 - 6*x**2 - x*(C2 - 7))]
+ assert dsolve(eqs1) == sol1
+ assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+ eqs2 = [Eq(Derivative(f(x), x), f(x) + g(x) + 5),
+ Eq(Derivative(g(x), x), f(x) + g(x) + 7)]
+ sol2 = [Eq(f(x), -C1 + C2*exp(2*x) - x - 3),
+ Eq(g(x), C1 + C2*exp(2*x) + x - 3)]
+ assert dsolve(eqs2) == sol2
+ assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+ eqs3 = [Eq(Derivative(f(x), x), f(x) + 5),
+ Eq(Derivative(g(x), x), f(x) + 7)]
+ sol3 = [Eq(f(x), C1*exp(x) - 5),
+ Eq(g(x), C1*exp(x) + C2 + 2*x - 5)]
+ assert dsolve(eqs3) == sol3
+ assert checksysodesol(eqs3, sol3) == (True, [0, 0])
+
+ eqs4 = [Eq(Derivative(f(x), x), f(x) + exp(x)),
+ Eq(Derivative(g(x), x), x*exp(x) + f(x) + g(x))]
+ sol4 = [Eq(f(x), C1*exp(x) + x*exp(x)),
+ Eq(g(x), C1*x*exp(x) + C2*exp(x) + x**2*exp(x))]
+ assert dsolve(eqs4) == sol4
+ assert checksysodesol(eqs4, sol4) == (True, [0, 0])
+
+ eqs5 = [Eq(Derivative(f(x), x), 5*x + f(x) + g(x)),
+ Eq(Derivative(g(x), x), f(x) - g(x))]
+ sol5 = [Eq(f(x), C1*(1 + sqrt(2))*exp(sqrt(2)*x) + C2*(1 - sqrt(2))*exp(-sqrt(2)*x) + x*Rational(-5, 2) +
+ Rational(-5, 2)),
+ Eq(g(x), C1*exp(sqrt(2)*x) + C2*exp(-sqrt(2)*x) + x*Rational(-5, 2))]
+ assert dsolve(eqs5) == sol5
+ assert checksysodesol(eqs5, sol5) == (True, [0, 0])
+
+ eqs6 = [Eq(Derivative(f(x), x), -9*f(x) - 4*g(x)),
+ Eq(Derivative(g(x), x), -4*g(x)),
+ Eq(Derivative(h(x), x), h(x) + exp(x))]
+ sol6 = [Eq(f(x), C2*exp(-4*x)*Rational(-4, 5) + C1*exp(-9*x)),
+ Eq(g(x), C2*exp(-4*x)),
+ Eq(h(x), C3*exp(x) + x*exp(x))]
+ assert dsolve(eqs6) == sol6
+ assert checksysodesol(eqs6, sol6) == (True, [0, 0, 0])
+
+ # Regression test case for issue #8859
+ # https://github.com/sympy/sympy/issues/8859
+ eqs7 = [Eq(Derivative(f(t), t), 3*t + f(t)),
+ Eq(Derivative(g(t), t), g(t))]
+ sol7 = [Eq(f(t), C1*exp(t) - 3*t - 3),
+ Eq(g(t), C2*exp(t))]
+ assert dsolve(eqs7) == sol7
+ assert checksysodesol(eqs7, sol7) == (True, [0, 0])
+
+ # Regression test case for issue #8567
+ # https://github.com/sympy/sympy/issues/8567
+ eqs8 = [Eq(Derivative(f(t), t), f(t) + 2*g(t)),
+ Eq(Derivative(g(t), t), -2*f(t) + g(t) + 2*exp(t))]
+ sol8 = [Eq(f(t), C1*exp(t)*sin(2*t) + C2*exp(t)*cos(2*t)
+ + exp(t)*sin(2*t)**2 + exp(t)*cos(2*t)**2),
+ Eq(g(t), C1*exp(t)*cos(2*t) - C2*exp(t)*sin(2*t))]
+ assert dsolve(eqs8) == sol8
+ assert checksysodesol(eqs8, sol8) == (True, [0, 0])
+
+ # Regression test case for issue #19150
+ # https://github.com/sympy/sympy/issues/19150
+ eqs9 = [Eq(Derivative(f(t), t), (c - 2*f(t) + g(t))/(a*b)),
+ Eq(Derivative(g(t), t), (f(t) - 2*g(t) + h(t))/(a*b)),
+ Eq(Derivative(h(t), t), (d + g(t) - 2*h(t))/(a*b))]
+ sol9 = [Eq(f(t), -C1*exp(-2*t/(a*b)) + C2*exp(-t*(sqrt(2) + 2)/(a*b)) + C3*exp(-t*(2 - sqrt(2))/(a*b)) +
+ Mul(Rational(1, 4), 3*c + d, evaluate=False)),
+ Eq(g(t), -sqrt(2)*C2*exp(-t*(sqrt(2) + 2)/(a*b)) + sqrt(2)*C3*exp(-t*(2 - sqrt(2))/(a*b)) +
+ Mul(Rational(1, 2), c + d, evaluate=False)),
+ Eq(h(t), C1*exp(-2*t/(a*b)) + C2*exp(-t*(sqrt(2) + 2)/(a*b)) + C3*exp(-t*(2 - sqrt(2))/(a*b)) +
+ Mul(Rational(1, 4), c + 3*d, evaluate=False))]
+ assert dsolve(eqs9) == sol9
+ assert checksysodesol(eqs9, sol9) == (True, [0, 0, 0])
+
+ # Regression test case for issue #16635
+ # https://github.com/sympy/sympy/issues/16635
+ eqs10 = [Eq(Derivative(f(t), t), 15*t + f(t) - g(t) - 10),
+ Eq(Derivative(g(t), t), -15*t + f(t) - g(t) - 5)]
+ sol10 = [Eq(f(t), C1 + C2 + 5*t**3 + 5*t**2 + t*(C2 - 10)),
+ Eq(g(t), C1 + 5*t**3 - 10*t**2 + t*(C2 - 5))]
+ assert dsolve(eqs10) == sol10
+ assert checksysodesol(eqs10, sol10) == (True, [0, 0])
+
+ # Multiple solutions
+ eqs11 = [Eq(Derivative(f(t), t)**2 - 2*Derivative(f(t), t) + 1, 4),
+ Eq(-y*f(t) + Derivative(g(t), t), 0)]
+ sol11 = [[Eq(f(t), C1 - t), Eq(g(t), C1*t*y + C2*y + t**2*y*Rational(-1, 2))],
+ [Eq(f(t), C1 + 3*t), Eq(g(t), C1*t*y + C2*y + t**2*y*Rational(3, 2))]]
+ assert dsolve(eqs11) == sol11
+ for s11 in sol11:
+ assert checksysodesol(eqs11, s11) == (True, [0, 0])
+
+ # test case for issue #19831
+ # https://github.com/sympy/sympy/issues/19831
+ n = symbols('n', positive=True)
+ x0 = symbols('x_0')
+ t0 = symbols('t_0')
+ x_0 = symbols('x_0')
+ t_0 = symbols('t_0')
+ t = symbols('t')
+ x = Function('x')
+ y = Function('y')
+ T = symbols('T')
+
+ eqs12 = [Eq(Derivative(y(t), t), x(t)),
+ Eq(Derivative(x(t), t), n*(y(t) + 1))]
+ sol12 = [Eq(y(t), C1*exp(sqrt(n)*t)*n**Rational(-1, 2) - C2*exp(-sqrt(n)*t)*n**Rational(-1, 2) - 1),
+ Eq(x(t), C1*exp(sqrt(n)*t) + C2*exp(-sqrt(n)*t))]
+ assert dsolve(eqs12) == sol12
+ assert checksysodesol(eqs12, sol12) == (True, [0, 0])
+
+ sol12b = [
+ Eq(y(t), (T*exp(-sqrt(n)*t_0)/2 + exp(-sqrt(n)*t_0)/2 +
+ x_0*exp(-sqrt(n)*t_0)/(2*sqrt(n)))*exp(sqrt(n)*t) +
+ (T*exp(sqrt(n)*t_0)/2 + exp(sqrt(n)*t_0)/2 -
+ x_0*exp(sqrt(n)*t_0)/(2*sqrt(n)))*exp(-sqrt(n)*t) - 1),
+ Eq(x(t), (T*sqrt(n)*exp(-sqrt(n)*t_0)/2 + sqrt(n)*exp(-sqrt(n)*t_0)/2
+ + x_0*exp(-sqrt(n)*t_0)/2)*exp(sqrt(n)*t)
+ - (T*sqrt(n)*exp(sqrt(n)*t_0)/2 + sqrt(n)*exp(sqrt(n)*t_0)/2 -
+ x_0*exp(sqrt(n)*t_0)/2)*exp(-sqrt(n)*t))
+ ]
+ assert dsolve(eqs12, ics={y(t0): T, x(t0): x0}) == sol12b
+ assert checksysodesol(eqs12, sol12b) == (True, [0, 0])
+
+ #Test cases added for the issue 19763
+ #https://github.com/sympy/sympy/issues/19763
+
+ eq13 = [Eq(Derivative(f(t), t), f(t) + g(t) + 9),
+ Eq(Derivative(g(t), t), 2*f(t) + 5*g(t) + 23)]
+ sol13 = [Eq(f(t), -C1*(2 + sqrt(6))*exp(t*(3 - sqrt(6)))/2 - C2*(2 - sqrt(6))*exp(t*(sqrt(6) + 3))/2 -
+ Rational(22,3)),
+ Eq(g(t), C1*exp(t*(3 - sqrt(6))) + C2*exp(t*(sqrt(6) + 3)) - Rational(5,3))]
+ assert dsolve(eq13) == sol13
+ assert checksysodesol(eq13, sol13) == (True, [0, 0])
+
+ eq14 = [Eq(Derivative(f(t), t), f(t) + g(t) + 81),
+ Eq(Derivative(g(t), t), -2*f(t) + g(t) + 23)]
+ sol14 = [Eq(f(t), sqrt(2)*C1*exp(t)*sin(sqrt(2)*t)/2
+ + sqrt(2)*C2*exp(t)*cos(sqrt(2)*t)/2
+ - 58*sin(sqrt(2)*t)**2/3 - 58*cos(sqrt(2)*t)**2/3),
+ Eq(g(t), C1*exp(t)*cos(sqrt(2)*t) - C2*exp(t)*sin(sqrt(2)*t)
+ - 185*sin(sqrt(2)*t)**2/3 - 185*cos(sqrt(2)*t)**2/3)]
+ assert dsolve(eq14) == sol14
+ assert checksysodesol(eq14, sol14) == (True, [0,0])
+
+ eq15 = [Eq(Derivative(f(t), t), f(t) + 2*g(t) + k1),
+ Eq(Derivative(g(t), t), 3*f(t) + 4*g(t) + k2)]
+ sol15 = [Eq(f(t), -C1*(3 - sqrt(33))*exp(t*(5 + sqrt(33))/2)/6 -
+ C2*(3 + sqrt(33))*exp(t*(5 - sqrt(33))/2)/6 + 2*k1 - k2),
+ Eq(g(t), C1*exp(t*(5 + sqrt(33))/2) + C2*exp(t*(5 - sqrt(33))/2) -
+ Mul(Rational(1,2), 3*k1 - k2, evaluate = False))]
+ assert dsolve(eq15) == sol15
+ assert checksysodesol(eq15, sol15) == (True, [0,0])
+
+ eq16 = [Eq(Derivative(f(t), t), k1),
+ Eq(Derivative(g(t), t), k2)]
+ sol16 = [Eq(f(t), C1 + k1*t),
+ Eq(g(t), C2 + k2*t)]
+ assert dsolve(eq16) == sol16
+ assert checksysodesol(eq16, sol16) == (True, [0,0])
+
+ eq17 = [Eq(Derivative(f(t), t), 0),
+ Eq(Derivative(g(t), t), c*f(t) + k2)]
+ sol17 = [Eq(f(t), C1),
+ Eq(g(t), C2*c + t*(C1*c + k2))]
+ assert dsolve(eq17) == sol17
+ assert checksysodesol(eq17 , sol17) == (True , [0,0])
+
+ eq18 = [Eq(Derivative(f(t), t), k1),
+ Eq(Derivative(g(t), t), f(t) + k2)]
+ sol18 = [Eq(f(t), C1 + k1*t),
+ Eq(g(t), C2 + k1*t**2/2 + t*(C1 + k2))]
+ assert dsolve(eq18) == sol18
+ assert checksysodesol(eq18 , sol18) == (True , [0,0])
+
+ eq19 = [Eq(Derivative(f(t), t), k1),
+ Eq(Derivative(g(t), t), f(t) + 2*g(t) + k2)]
+ sol19 = [Eq(f(t), -2*C1 + k1*t),
+ Eq(g(t), C1 + C2*exp(2*t) - k1*t/2 - Mul(Rational(1,4), k1 + 2*k2 , evaluate = False))]
+ assert dsolve(eq19) == sol19
+ assert checksysodesol(eq19 , sol19) == (True , [0,0])
+
+ eq20 = [Eq(diff(f(t), t), f(t) + k1),
+ Eq(diff(g(t), t), k2)]
+ sol20 = [Eq(f(t), C1*exp(t) - k1),
+ Eq(g(t), C2 + k2*t)]
+ assert dsolve(eq20) == sol20
+ assert checksysodesol(eq20 , sol20) == (True , [0,0])
+
+ eq21 = [Eq(diff(f(t), t), g(t) + k1),
+ Eq(diff(g(t), t), 0)]
+ sol21 = [Eq(f(t), C1 + t*(C2 + k1)),
+ Eq(g(t), C2)]
+ assert dsolve(eq21) == sol21
+ assert checksysodesol(eq21 , sol21) == (True , [0,0])
+
+ eq22 = [Eq(Derivative(f(t), t), f(t) + 2*g(t) + k1),
+ Eq(Derivative(g(t), t), k2)]
+ sol22 = [Eq(f(t), -2*C1 + C2*exp(t) - k1 - 2*k2*t - 2*k2),
+ Eq(g(t), C1 + k2*t)]
+ assert dsolve(eq22) == sol22
+ assert checksysodesol(eq22 , sol22) == (True , [0,0])
+
+ eq23 = [Eq(Derivative(f(t), t), g(t) + k1),
+ Eq(Derivative(g(t), t), 2*g(t) + k2)]
+ sol23 = [Eq(f(t), C1 + C2*exp(2*t)/2 - k2/4 + t*(2*k1 - k2)/2),
+ Eq(g(t), C2*exp(2*t) - k2/2)]
+ assert dsolve(eq23) == sol23
+ assert checksysodesol(eq23 , sol23) == (True , [0,0])
+
+ eq24 = [Eq(Derivative(f(t), t), f(t) + k1),
+ Eq(Derivative(g(t), t), 2*f(t) + k2)]
+ sol24 = [Eq(f(t), C1*exp(t)/2 - k1),
+ Eq(g(t), C1*exp(t) + C2 - 2*k1 - t*(2*k1 - k2))]
+ assert dsolve(eq24) == sol24
+ assert checksysodesol(eq24 , sol24) == (True , [0,0])
+
+ eq25 = [Eq(Derivative(f(t), t), f(t) + 2*g(t) + k1),
+ Eq(Derivative(g(t), t), 3*f(t) + 6*g(t) + k2)]
+ sol25 = [Eq(f(t), -2*C1 + C2*exp(7*t)/3 + 2*t*(3*k1 - k2)/7 -
+ Mul(Rational(1,49), k1 + 2*k2 , evaluate = False)),
+ Eq(g(t), C1 + C2*exp(7*t) - t*(3*k1 - k2)/7 -
+ Mul(Rational(3,49), k1 + 2*k2 , evaluate = False))]
+ assert dsolve(eq25) == sol25
+ assert checksysodesol(eq25 , sol25) == (True , [0,0])
+
+ eq26 = [Eq(Derivative(f(t), t), 2*f(t) - g(t) + k1),
+ Eq(Derivative(g(t), t), 4*f(t) - 2*g(t) + 2*k1)]
+ sol26 = [Eq(f(t), C1 + 2*C2 + t*(2*C1 + k1)),
+ Eq(g(t), 4*C2 + t*(4*C1 + 2*k1))]
+ assert dsolve(eq26) == sol26
+ assert checksysodesol(eq26 , sol26) == (True , [0,0])
+
+ # Test Case added for issue #22715
+ # https://github.com/sympy/sympy/issues/22715
+
+ eq27 = [Eq(diff(x(t),t),-1*y(t)+10), Eq(diff(y(t),t),5*x(t)-2*y(t)+3)]
+ sol27 = [Eq(x(t), (C1/5 - 2*C2/5)*exp(-t)*cos(2*t)
+ - (2*C1/5 + C2/5)*exp(-t)*sin(2*t)
+ + 17*sin(2*t)**2/5 + 17*cos(2*t)**2/5),
+ Eq(y(t), C1*exp(-t)*cos(2*t) - C2*exp(-t)*sin(2*t)
+ + 10*sin(2*t)**2 + 10*cos(2*t)**2)]
+ assert dsolve(eq27) == sol27
+ assert checksysodesol(eq27 , sol27) == (True , [0,0])
+
+
+def test_sysode_linear_neq_order1_type3():
+
+ f, g, h, k, x0 , y0 = symbols('f g h k x0 y0', cls=Function)
+ x, t, a = symbols('x t a')
+ r = symbols('r', real=True)
+
+ eqs1 = [Eq(Derivative(f(r), r), r*g(r) + f(r)),
+ Eq(Derivative(g(r), r), -r*f(r) + g(r))]
+ sol1 = [Eq(f(r), C1*exp(r)*sin(r**2/2) + C2*exp(r)*cos(r**2/2)),
+ Eq(g(r), C1*exp(r)*cos(r**2/2) - C2*exp(r)*sin(r**2/2))]
+ assert dsolve(eqs1) == sol1
+ assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+ eqs2 = [Eq(Derivative(f(x), x), x**2*g(x) + x*f(x)),
+ Eq(Derivative(g(x), x), 2*x**2*f(x) + (3*x**2 + x)*g(x))]
+ sol2 = [Eq(f(x), (sqrt(17)*C1/17 + C2*(17 - 3*sqrt(17))/34)*exp(x**3*(3 + sqrt(17))/6 + x**2/2) -
+ exp(x**3*(3 - sqrt(17))/6 + x**2/2)*(sqrt(17)*C1/17 + C2*(3*sqrt(17) + 17)*Rational(-1, 34))),
+ Eq(g(x), exp(x**3*(3 - sqrt(17))/6 + x**2/2)*(C1*(17 - 3*sqrt(17))/34 + sqrt(17)*C2*Rational(-2,
+ 17)) + exp(x**3*(3 + sqrt(17))/6 + x**2/2)*(C1*(3*sqrt(17) + 17)/34 + sqrt(17)*C2*Rational(2, 17)))]
+ assert dsolve(eqs2) == sol2
+ assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+ eqs3 = [Eq(f(x).diff(x), x*f(x) + g(x)),
+ Eq(g(x).diff(x), -f(x) + x*g(x))]
+ sol3 = [Eq(f(x), (C1/2 + I*C2/2)*exp(x**2/2 - I*x) + exp(x**2/2 + I*x)*(C1/2 + I*C2*Rational(-1, 2))),
+ Eq(g(x), (I*C1/2 + C2/2)*exp(x**2/2 + I*x) - exp(x**2/2 - I*x)*(I*C1/2 + C2*Rational(-1, 2)))]
+ assert dsolve(eqs3) == sol3
+ assert checksysodesol(eqs3, sol3) == (True, [0, 0])
+
+ eqs4 = [Eq(f(x).diff(x), x*(f(x) + g(x) + h(x))), Eq(g(x).diff(x), x*(f(x) + g(x) + h(x))),
+ Eq(h(x).diff(x), x*(f(x) + g(x) + h(x)))]
+ sol4 = [Eq(f(x), -C1/3 - C2/3 + 2*C3/3 + (C1/3 + C2/3 + C3/3)*exp(3*x**2/2)),
+ Eq(g(x), 2*C1/3 - C2/3 - C3/3 + (C1/3 + C2/3 + C3/3)*exp(3*x**2/2)),
+ Eq(h(x), -C1/3 + 2*C2/3 - C3/3 + (C1/3 + C2/3 + C3/3)*exp(3*x**2/2))]
+ assert dsolve(eqs4) == sol4
+ assert checksysodesol(eqs4, sol4) == (True, [0, 0, 0])
+
+ eqs5 = [Eq(f(x).diff(x), x**2*(f(x) + g(x) + h(x))), Eq(g(x).diff(x), x**2*(f(x) + g(x) + h(x))),
+ Eq(h(x).diff(x), x**2*(f(x) + g(x) + h(x)))]
+ sol5 = [Eq(f(x), -C1/3 - C2/3 + 2*C3/3 + (C1/3 + C2/3 + C3/3)*exp(x**3)),
+ Eq(g(x), 2*C1/3 - C2/3 - C3/3 + (C1/3 + C2/3 + C3/3)*exp(x**3)),
+ Eq(h(x), -C1/3 + 2*C2/3 - C3/3 + (C1/3 + C2/3 + C3/3)*exp(x**3))]
+ assert dsolve(eqs5) == sol5
+ assert checksysodesol(eqs5, sol5) == (True, [0, 0, 0])
+
+ eqs6 = [Eq(Derivative(f(x), x), x*(f(x) + g(x) + h(x) + k(x))),
+ Eq(Derivative(g(x), x), x*(f(x) + g(x) + h(x) + k(x))),
+ Eq(Derivative(h(x), x), x*(f(x) + g(x) + h(x) + k(x))),
+ Eq(Derivative(k(x), x), x*(f(x) + g(x) + h(x) + k(x)))]
+ sol6 = [Eq(f(x), -C1/4 - C2/4 - C3/4 + 3*C4/4 + (C1/4 + C2/4 + C3/4 + C4/4)*exp(2*x**2)),
+ Eq(g(x), 3*C1/4 - C2/4 - C3/4 - C4/4 + (C1/4 + C2/4 + C3/4 + C4/4)*exp(2*x**2)),
+ Eq(h(x), -C1/4 + 3*C2/4 - C3/4 - C4/4 + (C1/4 + C2/4 + C3/4 + C4/4)*exp(2*x**2)),
+ Eq(k(x), -C1/4 - C2/4 + 3*C3/4 - C4/4 + (C1/4 + C2/4 + C3/4 + C4/4)*exp(2*x**2))]
+ assert dsolve(eqs6) == sol6
+ assert checksysodesol(eqs6, sol6) == (True, [0, 0, 0, 0])
+
+ y = symbols("y", real=True)
+
+ eqs7 = [Eq(Derivative(f(y), y), y*f(y) + g(y)),
+ Eq(Derivative(g(y), y), y*g(y) - f(y))]
+ sol7 = [Eq(f(y), C1*exp(y**2/2)*sin(y) + C2*exp(y**2/2)*cos(y)),
+ Eq(g(y), C1*exp(y**2/2)*cos(y) - C2*exp(y**2/2)*sin(y))]
+ assert dsolve(eqs7) == sol7
+ assert checksysodesol(eqs7, sol7) == (True, [0, 0])
+
+ #Test cases added for the issue 19763
+ #https://github.com/sympy/sympy/issues/19763
+
+ eqs8 = [Eq(Derivative(f(t), t), 5*t*f(t) + 2*h(t)),
+ Eq(Derivative(h(t), t), 2*f(t) + 5*t*h(t))]
+ sol8 = [Eq(f(t), Mul(-1, (C1/2 - C2/2), evaluate = False)*exp(5*t**2/2 - 2*t) + (C1/2 + C2/2)*exp(5*t**2/2 + 2*t)),
+ Eq(h(t), (C1/2 - C2/2)*exp(5*t**2/2 - 2*t) + (C1/2 + C2/2)*exp(5*t**2/2 + 2*t))]
+ assert dsolve(eqs8) == sol8
+ assert checksysodesol(eqs8, sol8) == (True, [0, 0])
+
+ eqs9 = [Eq(diff(f(t), t), 5*t*f(t) + t**2*g(t)),
+ Eq(diff(g(t), t), -t**2*f(t) + 5*t*g(t))]
+ sol9 = [Eq(f(t), (C1/2 - I*C2/2)*exp(I*t**3/3 + 5*t**2/2) + (C1/2 + I*C2/2)*exp(-I*t**3/3 + 5*t**2/2)),
+ Eq(g(t), Mul(-1, (I*C1/2 - C2/2) , evaluate = False)*exp(-I*t**3/3 + 5*t**2/2) + (I*C1/2 + C2/2)*exp(I*t**3/3 + 5*t**2/2))]
+ assert dsolve(eqs9) == sol9
+ assert checksysodesol(eqs9 , sol9) == (True , [0,0])
+
+ eqs10 = [Eq(diff(f(t), t), t**2*g(t) + 5*t*f(t)),
+ Eq(diff(g(t), t), -t**2*f(t) + (9*t**2 + 5*t)*g(t))]
+ sol10 = [Eq(f(t), (C1*(77 - 9*sqrt(77))/154 + sqrt(77)*C2/77)*exp(t**3*(sqrt(77) + 9)/6 + 5*t**2/2) + (C1*(77 + 9*sqrt(77))/154 - sqrt(77)*C2/77)*exp(t**3*(9 - sqrt(77))/6 + 5*t**2/2)),
+ Eq(g(t), (sqrt(77)*C1/77 + C2*(77 - 9*sqrt(77))/154)*exp(t**3*(9 - sqrt(77))/6 + 5*t**2/2) - (sqrt(77)*C1/77 - C2*(77 + 9*sqrt(77))/154)*exp(t**3*(sqrt(77) + 9)/6 + 5*t**2/2))]
+ assert dsolve(eqs10) == sol10
+ assert checksysodesol(eqs10 , sol10) == (True , [0,0])
+
+ eqs11 = [Eq(diff(f(t), t), 5*t*f(t) + t**2*g(t)),
+ Eq(diff(g(t), t), (1-t**2)*f(t) + (5*t + 9*t**2)*g(t))]
+ sol11 = [Eq(f(t), C1*x0(t) + C2*x0(t)*Integral(t**2*exp(Integral(5*t, t))*exp(Integral(9*t**2 + 5*t, t))/x0(t)**2, t)),
+ Eq(g(t), C1*y0(t) + C2*(y0(t)*Integral(t**2*exp(Integral(5*t, t))*exp(Integral(9*t**2 + 5*t, t))/x0(t)**2, t) + exp(Integral(5*t, t))*exp(Integral(9*t**2 + 5*t, t))/x0(t)))]
+ assert dsolve(eqs11) == sol11
+
+@slow
+def test_sysode_linear_neq_order1_type4():
+
+ f, g, h, k = symbols('f g h k', cls=Function)
+ x, t, a = symbols('x t a')
+ r = symbols('r', real=True)
+
+ eqs1 = [Eq(diff(f(r), r), f(r) + r*g(r) + r**2), Eq(diff(g(r), r), -r*f(r) + g(r) + r)]
+ sol1 = [Eq(f(r), C1*exp(r)*sin(r**2/2) + C2*exp(r)*cos(r**2/2) + exp(r)*sin(r**2/2)*Integral(r**2*exp(-r)*sin(r**2/2) +
+ r*exp(-r)*cos(r**2/2), r) + exp(r)*cos(r**2/2)*Integral(r**2*exp(-r)*cos(r**2/2) - r*exp(-r)*sin(r**2/2), r)),
+ Eq(g(r), C1*exp(r)*cos(r**2/2) - C2*exp(r)*sin(r**2/2) - exp(r)*sin(r**2/2)*Integral(r**2*exp(-r)*cos(r**2/2) -
+ r*exp(-r)*sin(r**2/2), r) + exp(r)*cos(r**2/2)*Integral(r**2*exp(-r)*sin(r**2/2) + r*exp(-r)*cos(r**2/2), r))]
+ assert dsolve(eqs1) == sol1
+ assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+ eqs2 = [Eq(diff(f(r), r), f(r) + r*g(r) + r), Eq(diff(g(r), r), -r*f(r) + g(r) + log(r))]
+ sol2 = [Eq(f(r), C1*exp(r)*sin(r**2/2) + C2*exp(r)*cos(r**2/2) + exp(r)*sin(r**2/2)*Integral(r*exp(-r)*sin(r**2/2) +
+ exp(-r)*log(r)*cos(r**2/2), r) + exp(r)*cos(r**2/2)*Integral(r*exp(-r)*cos(r**2/2) - exp(-r)*log(r)*sin(
+ r**2/2), r)),
+ Eq(g(r), C1*exp(r)*cos(r**2/2) - C2*exp(r)*sin(r**2/2) - exp(r)*sin(r**2/2)*Integral(r*exp(-r)*cos(r**2/2) -
+ exp(-r)*log(r)*sin(r**2/2), r) + exp(r)*cos(r**2/2)*Integral(r*exp(-r)*sin(r**2/2) + exp(-r)*log(r)*cos(
+ r**2/2), r))]
+ # XXX: dsolve hangs for this in integration
+ assert dsolve_system(eqs2, simplify=False, doit=False) == [sol2]
+ assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+ eqs3 = [Eq(Derivative(f(x), x), x*(f(x) + g(x) + h(x)) + x),
+ Eq(Derivative(g(x), x), x*(f(x) + g(x) + h(x)) + x),
+ Eq(Derivative(h(x), x), x*(f(x) + g(x) + h(x)) + 1)]
+ sol3 = [Eq(f(x), C1*Rational(-1, 3) + C2*Rational(-1, 3) + C3*Rational(2, 3) + x**2/6 + x*Rational(-1, 3) +
+ (C1/3 + C2/3 + C3/3)*exp(x**2*Rational(3, 2)) +
+ sqrt(6)*sqrt(pi)*erf(sqrt(6)*x/2)*exp(x**2*Rational(3, 2))/18 + Rational(-2, 9)),
+ Eq(g(x), C1*Rational(2, 3) + C2*Rational(-1, 3) + C3*Rational(-1, 3) + x**2/6 + x*Rational(-1, 3) +
+ (C1/3 + C2/3 + C3/3)*exp(x**2*Rational(3, 2)) +
+ sqrt(6)*sqrt(pi)*erf(sqrt(6)*x/2)*exp(x**2*Rational(3, 2))/18 + Rational(-2, 9)),
+ Eq(h(x), C1*Rational(-1, 3) + C2*Rational(2, 3) + C3*Rational(-1, 3) + x**2*Rational(-1, 3) +
+ x*Rational(2, 3) + (C1/3 + C2/3 + C3/3)*exp(x**2*Rational(3, 2)) +
+ sqrt(6)*sqrt(pi)*erf(sqrt(6)*x/2)*exp(x**2*Rational(3, 2))/18 + Rational(-2, 9))]
+ assert dsolve(eqs3) == sol3
+ assert checksysodesol(eqs3, sol3) == (True, [0, 0, 0])
+
+ eqs4 = [Eq(Derivative(f(x), x), x*(f(x) + g(x) + h(x)) + sin(x)),
+ Eq(Derivative(g(x), x), x*(f(x) + g(x) + h(x)) + sin(x)),
+ Eq(Derivative(h(x), x), x*(f(x) + g(x) + h(x)) + sin(x))]
+ sol4 = [Eq(f(x), C1*Rational(-1, 3) + C2*Rational(-1, 3) + C3*Rational(2, 3) + (C1/3 + C2/3 +
+ C3/3)*exp(x**2*Rational(3, 2)) + Integral(sin(x)*exp(x**2*Rational(-3, 2)), x)*exp(x**2*Rational(3,
+ 2))),
+ Eq(g(x), C1*Rational(2, 3) + C2*Rational(-1, 3) + C3*Rational(-1, 3) + (C1/3 + C2/3 +
+ C3/3)*exp(x**2*Rational(3, 2)) + Integral(sin(x)*exp(x**2*Rational(-3, 2)), x)*exp(x**2*Rational(3,
+ 2))),
+ Eq(h(x), C1*Rational(-1, 3) + C2*Rational(2, 3) + C3*Rational(-1, 3) + (C1/3 + C2/3 +
+ C3/3)*exp(x**2*Rational(3, 2)) + Integral(sin(x)*exp(x**2*Rational(-3, 2)), x)*exp(x**2*Rational(3,
+ 2)))]
+ assert dsolve(eqs4) == sol4
+ assert checksysodesol(eqs4, sol4) == (True, [0, 0, 0])
+
+ eqs5 = [Eq(Derivative(f(x), x), x*(f(x) + g(x) + h(x) + k(x) + 1)),
+ Eq(Derivative(g(x), x), x*(f(x) + g(x) + h(x) + k(x) + 1)),
+ Eq(Derivative(h(x), x), x*(f(x) + g(x) + h(x) + k(x) + 1)),
+ Eq(Derivative(k(x), x), x*(f(x) + g(x) + h(x) + k(x) + 1))]
+ sol5 = [Eq(f(x), C1*Rational(-1, 4) + C2*Rational(-1, 4) + C3*Rational(-1, 4) + C4*Rational(3, 4) + (C1/4 +
+ C2/4 + C3/4 + C4/4)*exp(2*x**2) + Rational(-1, 4)),
+ Eq(g(x), C1*Rational(3, 4) + C2*Rational(-1, 4) + C3*Rational(-1, 4) + C4*Rational(-1, 4) + (C1/4 +
+ C2/4 + C3/4 + C4/4)*exp(2*x**2) + Rational(-1, 4)),
+ Eq(h(x), C1*Rational(-1, 4) + C2*Rational(3, 4) + C3*Rational(-1, 4) + C4*Rational(-1, 4) + (C1/4 +
+ C2/4 + C3/4 + C4/4)*exp(2*x**2) + Rational(-1, 4)),
+ Eq(k(x), C1*Rational(-1, 4) + C2*Rational(-1, 4) + C3*Rational(3, 4) + C4*Rational(-1, 4) + (C1/4 +
+ C2/4 + C3/4 + C4/4)*exp(2*x**2) + Rational(-1, 4))]
+ assert dsolve(eqs5) == sol5
+ assert checksysodesol(eqs5, sol5) == (True, [0, 0, 0, 0])
+
+ eqs6 = [Eq(Derivative(f(x), x), x**2*(f(x) + g(x) + h(x) + k(x) + 1)),
+ Eq(Derivative(g(x), x), x**2*(f(x) + g(x) + h(x) + k(x) + 1)),
+ Eq(Derivative(h(x), x), x**2*(f(x) + g(x) + h(x) + k(x) + 1)),
+ Eq(Derivative(k(x), x), x**2*(f(x) + g(x) + h(x) + k(x) + 1))]
+ sol6 = [Eq(f(x), C1*Rational(-1, 4) + C2*Rational(-1, 4) + C3*Rational(-1, 4) + C4*Rational(3, 4) + (C1/4 +
+ C2/4 + C3/4 + C4/4)*exp(x**3*Rational(4, 3)) + Rational(-1, 4)),
+ Eq(g(x), C1*Rational(3, 4) + C2*Rational(-1, 4) + C3*Rational(-1, 4) + C4*Rational(-1, 4) + (C1/4 +
+ C2/4 + C3/4 + C4/4)*exp(x**3*Rational(4, 3)) + Rational(-1, 4)),
+ Eq(h(x), C1*Rational(-1, 4) + C2*Rational(3, 4) + C3*Rational(-1, 4) + C4*Rational(-1, 4) + (C1/4 +
+ C2/4 + C3/4 + C4/4)*exp(x**3*Rational(4, 3)) + Rational(-1, 4)),
+ Eq(k(x), C1*Rational(-1, 4) + C2*Rational(-1, 4) + C3*Rational(3, 4) + C4*Rational(-1, 4) + (C1/4 +
+ C2/4 + C3/4 + C4/4)*exp(x**3*Rational(4, 3)) + Rational(-1, 4))]
+ assert dsolve(eqs6) == sol6
+ assert checksysodesol(eqs6, sol6) == (True, [0, 0, 0, 0])
+
+ eqs7 = [Eq(Derivative(f(x), x), (f(x) + g(x) + h(x))*log(x) + sin(x)), Eq(Derivative(g(x), x), (f(x) + g(x)
+ + h(x))*log(x) + sin(x)), Eq(Derivative(h(x), x), (f(x) + g(x) + h(x))*log(x) + sin(x))]
+ sol7 = [Eq(f(x), -C1/3 - C2/3 + 2*C3/3 + (C1/3 + C2/3 +
+ C3/3)*exp(x*(3*log(x) - 3)) + exp(x*(3*log(x) -
+ 3))*Integral(exp(3*x)*exp(-3*x*log(x))*sin(x), x)),
+ Eq(g(x), 2*C1/3 - C2/3 - C3/3 + (C1/3 + C2/3 +
+ C3/3)*exp(x*(3*log(x) - 3)) + exp(x*(3*log(x) -
+ 3))*Integral(exp(3*x)*exp(-3*x*log(x))*sin(x), x)),
+ Eq(h(x), -C1/3 + 2*C2/3 - C3/3 + (C1/3 + C2/3 +
+ C3/3)*exp(x*(3*log(x) - 3)) + exp(x*(3*log(x) -
+ 3))*Integral(exp(3*x)*exp(-3*x*log(x))*sin(x), x))]
+ with dotprodsimp(True):
+ assert dsolve(eqs7, simplify=False, doit=False) == sol7
+ assert checksysodesol(eqs7, sol7) == (True, [0, 0, 0])
+
+ eqs8 = [Eq(Derivative(f(x), x), (f(x) + g(x) + h(x) + k(x))*log(x) + sin(x)), Eq(Derivative(g(x), x), (f(x)
+ + g(x) + h(x) + k(x))*log(x) + sin(x)), Eq(Derivative(h(x), x), (f(x) + g(x) + h(x) + k(x))*log(x) +
+ sin(x)), Eq(Derivative(k(x), x), (f(x) + g(x) + h(x) + k(x))*log(x) + sin(x))]
+ sol8 = [Eq(f(x), -C1/4 - C2/4 - C3/4 + 3*C4/4 + (C1/4 + C2/4 + C3/4 +
+ C4/4)*exp(x*(4*log(x) - 4)) + exp(x*(4*log(x) -
+ 4))*Integral(exp(4*x)*exp(-4*x*log(x))*sin(x), x)),
+ Eq(g(x), 3*C1/4 - C2/4 - C3/4 - C4/4 + (C1/4 + C2/4 + C3/4 +
+ C4/4)*exp(x*(4*log(x) - 4)) + exp(x*(4*log(x) -
+ 4))*Integral(exp(4*x)*exp(-4*x*log(x))*sin(x), x)),
+ Eq(h(x), -C1/4 + 3*C2/4 - C3/4 - C4/4 + (C1/4 + C2/4 + C3/4 +
+ C4/4)*exp(x*(4*log(x) - 4)) + exp(x*(4*log(x) -
+ 4))*Integral(exp(4*x)*exp(-4*x*log(x))*sin(x), x)),
+ Eq(k(x), -C1/4 - C2/4 + 3*C3/4 - C4/4 + (C1/4 + C2/4 + C3/4 +
+ C4/4)*exp(x*(4*log(x) - 4)) + exp(x*(4*log(x) -
+ 4))*Integral(exp(4*x)*exp(-4*x*log(x))*sin(x), x))]
+ with dotprodsimp(True):
+ assert dsolve(eqs8) == sol8
+ assert checksysodesol(eqs8, sol8) == (True, [0, 0, 0, 0])
+
+
+def test_sysode_linear_neq_order1_type5_type6():
+ f, g = symbols("f g", cls=Function)
+ x, x_ = symbols("x x_")
+
+ # Type 5
+ eqs1 = [Eq(Derivative(f(x), x), (2*f(x) + g(x))/x), Eq(Derivative(g(x), x), (f(x) + 2*g(x))/x)]
+ sol1 = [Eq(f(x), -C1*x + C2*x**3), Eq(g(x), C1*x + C2*x**3)]
+ assert dsolve(eqs1) == sol1
+ assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+ # Type 6
+ eqs2 = [Eq(Derivative(f(x), x), (2*f(x) + g(x) + 1)/x),
+ Eq(Derivative(g(x), x), (x + f(x) + 2*g(x))/x)]
+ sol2 = [Eq(f(x), C2*x**3 - x*(C1 + Rational(1, 4)) + x*log(x)*Rational(-1, 2) + Rational(-2, 3)),
+ Eq(g(x), C2*x**3 + x*log(x)/2 + x*(C1 + Rational(-1, 4)) + Rational(1, 3))]
+ assert dsolve(eqs2) == sol2
+ assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+
+def test_higher_order_to_first_order():
+ f, g = symbols('f g', cls=Function)
+ x = symbols('x')
+
+ eqs1 = [Eq(Derivative(f(x), (x, 2)), 2*f(x) + g(x)),
+ Eq(Derivative(g(x), (x, 2)), -f(x))]
+ sol1 = [Eq(f(x), -C2*x*exp(-x) + C3*x*exp(x) - (C1 - C2)*exp(-x) + (C3 + C4)*exp(x)),
+ Eq(g(x), C2*x*exp(-x) - C3*x*exp(x) + (C1 + C2)*exp(-x) + (C3 - C4)*exp(x))]
+ assert dsolve(eqs1) == sol1
+ assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+ eqs2 = [Eq(f(x).diff(x, 2), 0), Eq(g(x).diff(x, 2), f(x))]
+ sol2 = [Eq(f(x), C1 + C2*x), Eq(g(x), C1*x**2/2 + C2*x**3/6 + C3 + C4*x)]
+ assert dsolve(eqs2) == sol2
+ assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+ eqs3 = [Eq(Derivative(f(x), (x, 2)), 2*f(x)),
+ Eq(Derivative(g(x), (x, 2)), -f(x) + 2*g(x))]
+ sol3 = [Eq(f(x), 4*C1*exp(-sqrt(2)*x) + 4*C2*exp(sqrt(2)*x)),
+ Eq(g(x), sqrt(2)*C1*x*exp(-sqrt(2)*x) - sqrt(2)*C2*x*exp(sqrt(2)*x) + (C1 +
+ sqrt(2)*C4)*exp(-sqrt(2)*x) + (C2 - sqrt(2)*C3)*exp(sqrt(2)*x))]
+ assert dsolve(eqs3) == sol3
+ assert checksysodesol(eqs3, sol3) == (True, [0, 0])
+
+ eqs4 = [Eq(Derivative(f(x), (x, 2)), 2*f(x) + g(x)),
+ Eq(Derivative(g(x), (x, 2)), 2*g(x))]
+ sol4 = [Eq(f(x), C1*x*exp(sqrt(2)*x)/4 + C3*x*exp(-sqrt(2)*x)/4 + (C2/4 + sqrt(2)*C3/8)*exp(-sqrt(2)*x) -
+ exp(sqrt(2)*x)*(sqrt(2)*C1/8 + C4*Rational(-1, 4))),
+ Eq(g(x), sqrt(2)*C1*exp(sqrt(2)*x)/2 + sqrt(2)*C3*exp(-sqrt(2)*x)*Rational(-1, 2))]
+ assert dsolve(eqs4) == sol4
+ assert checksysodesol(eqs4, sol4) == (True, [0, 0])
+
+ eqs5 = [Eq(f(x).diff(x, 2), f(x)), Eq(g(x).diff(x, 2), f(x))]
+ sol5 = [Eq(f(x), -C1*exp(-x) + C2*exp(x)), Eq(g(x), -C1*exp(-x) + C2*exp(x) + C3 + C4*x)]
+ assert dsolve(eqs5) == sol5
+ assert checksysodesol(eqs5, sol5) == (True, [0, 0])
+
+ eqs6 = [Eq(Derivative(f(x), (x, 2)), f(x) + g(x)),
+ Eq(Derivative(g(x), (x, 2)), -f(x) - g(x))]
+ sol6 = [Eq(f(x), C1 + C2*x**2/2 + C2 + C4*x**3/6 + x*(C3 + C4)),
+ Eq(g(x), -C1 + C2*x**2*Rational(-1, 2) - C3*x + C4*x**3*Rational(-1, 6))]
+ assert dsolve(eqs6) == sol6
+ assert checksysodesol(eqs6, sol6) == (True, [0, 0])
+
+ eqs7 = [Eq(Derivative(f(x), (x, 2)), f(x) + g(x) + 1),
+ Eq(Derivative(g(x), (x, 2)), f(x) + g(x) + 1)]
+ sol7 = [Eq(f(x), -C1 - C2*x + sqrt(2)*C3*exp(sqrt(2)*x)/2 + sqrt(2)*C4*exp(-sqrt(2)*x)*Rational(-1, 2) +
+ Rational(-1, 2)),
+ Eq(g(x), C1 + C2*x + sqrt(2)*C3*exp(sqrt(2)*x)/2 + sqrt(2)*C4*exp(-sqrt(2)*x)*Rational(-1, 2) +
+ Rational(-1, 2))]
+ assert dsolve(eqs7) == sol7
+ assert checksysodesol(eqs7, sol7) == (True, [0, 0])
+
+ eqs8 = [Eq(Derivative(f(x), (x, 2)), f(x) + g(x) + 1),
+ Eq(Derivative(g(x), (x, 2)), -f(x) - g(x) + 1)]
+ sol8 = [Eq(f(x), C1 + C2 + C4*x**3/6 + x**4/12 + x**2*(C2/2 + Rational(1, 2)) + x*(C3 + C4)),
+ Eq(g(x), -C1 - C3*x + C4*x**3*Rational(-1, 6) + x**4*Rational(-1, 12) - x**2*(C2/2 + Rational(-1,
+ 2)))]
+ assert dsolve(eqs8) == sol8
+ assert checksysodesol(eqs8, sol8) == (True, [0, 0])
+
+ x, y = symbols('x, y', cls=Function)
+ t, l = symbols('t, l')
+
+ eqs10 = [Eq(Derivative(x(t), (t, 2)), 5*x(t) + 43*y(t)),
+ Eq(Derivative(y(t), (t, 2)), x(t) + 9*y(t))]
+ sol10 = [Eq(x(t), C1*(61 - 9*sqrt(47))*sqrt(sqrt(47) + 7)*exp(-t*sqrt(sqrt(47) + 7))/2 + C2*sqrt(7 -
+ sqrt(47))*(61 + 9*sqrt(47))*exp(-t*sqrt(7 - sqrt(47)))/2 + C3*(61 - 9*sqrt(47))*sqrt(sqrt(47) +
+ 7)*exp(t*sqrt(sqrt(47) + 7))*Rational(-1, 2) + C4*sqrt(7 - sqrt(47))*(61 + 9*sqrt(47))*exp(t*sqrt(7
+ - sqrt(47)))*Rational(-1, 2)),
+ Eq(y(t), C1*(7 - sqrt(47))*sqrt(sqrt(47) + 7)*exp(-t*sqrt(sqrt(47) + 7))*Rational(-1, 2) + C2*sqrt(7
+ - sqrt(47))*(sqrt(47) + 7)*exp(-t*sqrt(7 - sqrt(47)))*Rational(-1, 2) + C3*(7 -
+ sqrt(47))*sqrt(sqrt(47) + 7)*exp(t*sqrt(sqrt(47) + 7))/2 + C4*sqrt(7 - sqrt(47))*(sqrt(47) +
+ 7)*exp(t*sqrt(7 - sqrt(47)))/2)]
+ assert dsolve(eqs10) == sol10
+ assert checksysodesol(eqs10, sol10) == (True, [0, 0])
+
+ eqs11 = [Eq(7*x(t) + Derivative(x(t), (t, 2)) - 9*Derivative(y(t), t), 0),
+ Eq(7*y(t) + 9*Derivative(x(t), t) + Derivative(y(t), (t, 2)), 0)]
+ sol11 = [Eq(y(t), C1*(9 - sqrt(109))*sin(sqrt(2)*t*sqrt(9*sqrt(109) + 95)/2)/14 + C2*(9 -
+ sqrt(109))*cos(sqrt(2)*t*sqrt(9*sqrt(109) + 95)/2)*Rational(-1, 14) + C3*(9 +
+ sqrt(109))*sin(sqrt(2)*t*sqrt(95 - 9*sqrt(109))/2)/14 + C4*(9 + sqrt(109))*cos(sqrt(2)*t*sqrt(95 -
+ 9*sqrt(109))/2)*Rational(-1, 14)),
+ Eq(x(t), C1*(9 - sqrt(109))*cos(sqrt(2)*t*sqrt(9*sqrt(109) + 95)/2)*Rational(-1, 14) + C2*(9 -
+ sqrt(109))*sin(sqrt(2)*t*sqrt(9*sqrt(109) + 95)/2)*Rational(-1, 14) + C3*(9 +
+ sqrt(109))*cos(sqrt(2)*t*sqrt(95 - 9*sqrt(109))/2)/14 + C4*(9 + sqrt(109))*sin(sqrt(2)*t*sqrt(95 -
+ 9*sqrt(109))/2)/14)]
+ assert dsolve(eqs11) == sol11
+ assert checksysodesol(eqs11, sol11) == (True, [0, 0])
+
+ # Euler Systems
+ # Note: To add examples of euler systems solver with non-homogeneous term.
+ eqs13 = [Eq(Derivative(f(t), (t, 2)), Derivative(f(t), t)/t + f(t)/t**2 + g(t)/t**2),
+ Eq(Derivative(g(t), (t, 2)), g(t)/t**2)]
+ sol13 = [Eq(f(t), C1*(sqrt(5) + 3)*Rational(-1, 2)*t**(Rational(1, 2) +
+ sqrt(5)*Rational(-1, 2)) + C2*t**(Rational(1, 2) +
+ sqrt(5)/2)*(3 - sqrt(5))*Rational(-1, 2) - C3*t**(1 -
+ sqrt(2))*(1 + sqrt(2)) - C4*t**(1 + sqrt(2))*(1 - sqrt(2))),
+ Eq(g(t), C1*(1 + sqrt(5))*Rational(-1, 2)*t**(Rational(1, 2) +
+ sqrt(5)*Rational(-1, 2)) + C2*t**(Rational(1, 2) +
+ sqrt(5)/2)*(1 - sqrt(5))*Rational(-1, 2))]
+ assert dsolve(eqs13) == sol13
+ assert checksysodesol(eqs13, sol13) == (True, [0, 0])
+
+ # Solving systems using dsolve separately
+ eqs14 = [Eq(Derivative(f(t), (t, 2)), t*f(t)),
+ Eq(Derivative(g(t), (t, 2)), t*g(t))]
+ sol14 = [Eq(f(t), C1*airyai(t) + C2*airybi(t)),
+ Eq(g(t), C3*airyai(t) + C4*airybi(t))]
+ assert dsolve(eqs14) == sol14
+ assert checksysodesol(eqs14, sol14) == (True, [0, 0])
+
+
+ eqs15 = [Eq(Derivative(x(t), (t, 2)), t*(4*Derivative(x(t), t) + 8*Derivative(y(t), t))),
+ Eq(Derivative(y(t), (t, 2)), t*(12*Derivative(x(t), t) - 6*Derivative(y(t), t)))]
+ sol15 = [Eq(x(t), C1 - erf(sqrt(6)*t)*(sqrt(6)*sqrt(pi)*C2/33 + sqrt(6)*sqrt(pi)*C3*Rational(-1, 44)) +
+ erfi(sqrt(5)*t)*(sqrt(5)*sqrt(pi)*C2*Rational(2, 55) + sqrt(5)*sqrt(pi)*C3*Rational(4, 55))),
+ Eq(y(t), C4 + erf(sqrt(6)*t)*(sqrt(6)*sqrt(pi)*C2*Rational(2, 33) + sqrt(6)*sqrt(pi)*C3*Rational(-1,
+ 22)) + erfi(sqrt(5)*t)*(sqrt(5)*sqrt(pi)*C2*Rational(3, 110) + sqrt(5)*sqrt(pi)*C3*Rational(3, 55)))]
+ assert dsolve(eqs15) == sol15
+ assert checksysodesol(eqs15, sol15) == (True, [0, 0])
+
+
+@slow
+def test_higher_order_to_first_order_9():
+ f, g = symbols('f g', cls=Function)
+ x = symbols('x')
+
+ eqs9 = [f(x) + g(x) - 2*exp(I*x) + 2*Derivative(f(x), x) + Derivative(f(x), (x, 2)),
+ f(x) + g(x) - 2*exp(I*x) + 2*Derivative(g(x), x) + Derivative(g(x), (x, 2))]
+ sol9 = [Eq(f(x), -C1 + C4*exp(-2*x)/2 - (C2/2 - C3/2)*exp(-x)*cos(x)
+ + (C2/2 + C3/2)*exp(-x)*sin(x) + 2*((1 - 2*I)*exp(I*x)*sin(x)**2/5)
+ + 2*((1 - 2*I)*exp(I*x)*cos(x)**2/5)),
+ Eq(g(x), C1 - C4*exp(-2*x)/2 - (C2/2 - C3/2)*exp(-x)*cos(x)
+ + (C2/2 + C3/2)*exp(-x)*sin(x) + 2*((1 - 2*I)*exp(I*x)*sin(x)**2/5)
+ + 2*((1 - 2*I)*exp(I*x)*cos(x)**2/5))]
+ assert dsolve(eqs9) == sol9
+ assert checksysodesol(eqs9, sol9) == (True, [0, 0])
+
+
+def test_higher_order_to_first_order_12():
+ f, g = symbols('f g', cls=Function)
+ x = symbols('x')
+
+ x, y = symbols('x, y', cls=Function)
+ t, l = symbols('t, l')
+
+ eqs12 = [Eq(4*x(t) + Derivative(x(t), (t, 2)) + 8*Derivative(y(t), t), 0),
+ Eq(4*y(t) - 8*Derivative(x(t), t) + Derivative(y(t), (t, 2)), 0)]
+ sol12 = [Eq(y(t), C1*(2 - sqrt(5))*sin(2*t*sqrt(4*sqrt(5) + 9))*Rational(-1, 2) + C2*(2 -
+ sqrt(5))*cos(2*t*sqrt(4*sqrt(5) + 9))/2 + C3*(2 + sqrt(5))*sin(2*t*sqrt(9 - 4*sqrt(5)))*Rational(-1,
+ 2) + C4*(2 + sqrt(5))*cos(2*t*sqrt(9 - 4*sqrt(5)))/2),
+ Eq(x(t), C1*(2 - sqrt(5))*cos(2*t*sqrt(4*sqrt(5) + 9))*Rational(-1, 2) + C2*(2 -
+ sqrt(5))*sin(2*t*sqrt(4*sqrt(5) + 9))*Rational(-1, 2) + C3*(2 + sqrt(5))*cos(2*t*sqrt(9 -
+ 4*sqrt(5)))/2 + C4*(2 + sqrt(5))*sin(2*t*sqrt(9 - 4*sqrt(5)))/2)]
+ assert dsolve(eqs12) == sol12
+ assert checksysodesol(eqs12, sol12) == (True, [0, 0])
+
+
+def test_second_order_to_first_order_2():
+ f, g = symbols("f g", cls=Function)
+ x, t, x_, t_, d, a, m = symbols("x t x_ t_ d a m")
+
+ eqs2 = [Eq(f(x).diff(x, 2), 2*(x*g(x).diff(x) - g(x))),
+ Eq(g(x).diff(x, 2),-2*(x*f(x).diff(x) - f(x)))]
+ sol2 = [Eq(f(x), C1*x + x*Integral(C2*exp(-x_)*exp(I*exp(2*x_))/2 + C2*exp(-x_)*exp(-I*exp(2*x_))/2 -
+ I*C3*exp(-x_)*exp(I*exp(2*x_))/2 + I*C3*exp(-x_)*exp(-I*exp(2*x_))/2, (x_, log(x)))),
+ Eq(g(x), C4*x + x*Integral(I*C2*exp(-x_)*exp(I*exp(2*x_))/2 - I*C2*exp(-x_)*exp(-I*exp(2*x_))/2 +
+ C3*exp(-x_)*exp(I*exp(2*x_))/2 + C3*exp(-x_)*exp(-I*exp(2*x_))/2, (x_, log(x))))]
+ # XXX: dsolve hangs for this in integration
+ assert dsolve_system(eqs2, simplify=False, doit=False) == [sol2]
+ assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+ eqs3 = (Eq(diff(f(t),t,t), 9*t*diff(g(t),t)-9*g(t)), Eq(diff(g(t),t,t),7*t*diff(f(t),t)-7*f(t)))
+ sol3 = [Eq(f(t), C1*t + t*Integral(C2*exp(-t_)*exp(3*sqrt(7)*exp(2*t_)/2)/2 + C2*exp(-t_)*
+ exp(-3*sqrt(7)*exp(2*t_)/2)/2 + 3*sqrt(7)*C3*exp(-t_)*exp(3*sqrt(7)*exp(2*t_)/2)/14 -
+ 3*sqrt(7)*C3*exp(-t_)*exp(-3*sqrt(7)*exp(2*t_)/2)/14, (t_, log(t)))),
+ Eq(g(t), C4*t + t*Integral(sqrt(7)*C2*exp(-t_)*exp(3*sqrt(7)*exp(2*t_)/2)/6 - sqrt(7)*C2*exp(-t_)*
+ exp(-3*sqrt(7)*exp(2*t_)/2)/6 + C3*exp(-t_)*exp(3*sqrt(7)*exp(2*t_)/2)/2 + C3*exp(-t_)*exp(-3*sqrt(7)*
+ exp(2*t_)/2)/2, (t_, log(t))))]
+ # XXX: dsolve hangs for this in integration
+ assert dsolve_system(eqs3, simplify=False, doit=False) == [sol3]
+ assert checksysodesol(eqs3, sol3) == (True, [0, 0])
+
+ # Regression Test case for sympy#19238
+ # https://github.com/sympy/sympy/issues/19238
+ # Note: When the doit method is removed, these particular types of systems
+ # can be divided first so that we have lesser number of big matrices.
+ eqs5 = [Eq(Derivative(g(t), (t, 2)), a*m),
+ Eq(Derivative(f(t), (t, 2)), 0)]
+ sol5 = [Eq(g(t), C1 + C2*t + a*m*t**2/2),
+ Eq(f(t), C3 + C4*t)]
+ assert dsolve(eqs5) == sol5
+ assert checksysodesol(eqs5, sol5) == (True, [0, 0])
+
+ # Type 2
+ eqs6 = [Eq(Derivative(f(t), (t, 2)), f(t)/t**4),
+ Eq(Derivative(g(t), (t, 2)), d*g(t)/t**4)]
+ sol6 = [Eq(f(t), C1*sqrt(t**2)*exp(-1/t) - C2*sqrt(t**2)*exp(1/t)),
+ Eq(g(t), C3*sqrt(t**2)*exp(-sqrt(d)/t)*d**Rational(-1, 2) -
+ C4*sqrt(t**2)*exp(sqrt(d)/t)*d**Rational(-1, 2))]
+ assert dsolve(eqs6) == sol6
+ assert checksysodesol(eqs6, sol6) == (True, [0, 0])
+
+
+@slow
+def test_second_order_to_first_order_slow1():
+ f, g = symbols("f g", cls=Function)
+ x, t, x_, t_, d, a, m = symbols("x t x_ t_ d a m")
+
+ # Type 1
+
+ eqs1 = [Eq(f(x).diff(x, 2), 2/x *(x*g(x).diff(x) - g(x))),
+ Eq(g(x).diff(x, 2),-2/x *(x*f(x).diff(x) - f(x)))]
+ sol1 = [Eq(f(x), C1*x + 2*C2*x*Ci(2*x) - C2*sin(2*x) - 2*C3*x*Si(2*x) - C3*cos(2*x)),
+ Eq(g(x), -2*C2*x*Si(2*x) - C2*cos(2*x) - 2*C3*x*Ci(2*x) + C3*sin(2*x) + C4*x)]
+ assert dsolve(eqs1) == sol1
+ assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+
+def test_second_order_to_first_order_slow4():
+ f, g = symbols("f g", cls=Function)
+ x, t, x_, t_, d, a, m = symbols("x t x_ t_ d a m")
+
+ eqs4 = [Eq(Derivative(f(t), (t, 2)), t*sin(t)*Derivative(g(t), t) - g(t)*sin(t)),
+ Eq(Derivative(g(t), (t, 2)), t*sin(t)*Derivative(f(t), t) - f(t)*sin(t))]
+ sol4 = [Eq(f(t), C1*t + t*Integral(C2*exp(-t_)*exp(exp(t_)*cos(exp(t_)))*exp(-sin(exp(t_)))/2 +
+ C2*exp(-t_)*exp(-exp(t_)*cos(exp(t_)))*exp(sin(exp(t_)))/2 - C3*exp(-t_)*exp(exp(t_)*cos(exp(t_)))*
+ exp(-sin(exp(t_)))/2 +
+ C3*exp(-t_)*exp(-exp(t_)*cos(exp(t_)))*exp(sin(exp(t_)))/2, (t_, log(t)))),
+ Eq(g(t), C4*t + t*Integral(-C2*exp(-t_)*exp(exp(t_)*cos(exp(t_)))*exp(-sin(exp(t_)))/2 +
+ C2*exp(-t_)*exp(-exp(t_)*cos(exp(t_)))*exp(sin(exp(t_)))/2 + C3*exp(-t_)*exp(exp(t_)*cos(exp(t_)))*
+ exp(-sin(exp(t_)))/2 + C3*exp(-t_)*exp(-exp(t_)*cos(exp(t_)))*exp(sin(exp(t_)))/2, (t_, log(t))))]
+ # XXX: dsolve hangs for this in integration
+ assert dsolve_system(eqs4, simplify=False, doit=False) == [sol4]
+ assert checksysodesol(eqs4, sol4) == (True, [0, 0])
+
+
+def test_component_division():
+ f, g, h, k = symbols('f g h k', cls=Function)
+ x = symbols("x")
+ funcs = [f(x), g(x), h(x), k(x)]
+
+ eqs1 = [Eq(Derivative(f(x), x), 2*f(x)),
+ Eq(Derivative(g(x), x), f(x)),
+ Eq(Derivative(h(x), x), h(x)),
+ Eq(Derivative(k(x), x), h(x)**4 + k(x))]
+ sol1 = [Eq(f(x), 2*C1*exp(2*x)),
+ Eq(g(x), C1*exp(2*x) + C2),
+ Eq(h(x), C3*exp(x)),
+ Eq(k(x), C3**4*exp(4*x)/3 + C4*exp(x))]
+ assert dsolve(eqs1) == sol1
+ assert checksysodesol(eqs1, sol1) == (True, [0, 0, 0, 0])
+
+ components1 = {((Eq(Derivative(f(x), x), 2*f(x)),), (Eq(Derivative(g(x), x), f(x)),)),
+ ((Eq(Derivative(h(x), x), h(x)),), (Eq(Derivative(k(x), x), h(x)**4 + k(x)),))}
+ eqsdict1 = ({f(x): set(), g(x): {f(x)}, h(x): set(), k(x): {h(x)}},
+ {f(x): Eq(Derivative(f(x), x), 2*f(x)),
+ g(x): Eq(Derivative(g(x), x), f(x)),
+ h(x): Eq(Derivative(h(x), x), h(x)),
+ k(x): Eq(Derivative(k(x), x), h(x)**4 + k(x))})
+ graph1 = [{f(x), g(x), h(x), k(x)}, {(g(x), f(x)), (k(x), h(x))}]
+ assert {tuple(tuple(scc) for scc in wcc) for wcc in _component_division(eqs1, funcs, x)} == components1
+ assert _eqs2dict(eqs1, funcs) == eqsdict1
+ assert [set(element) for element in _dict2graph(eqsdict1[0])] == graph1
+
+ eqs2 = [Eq(Derivative(f(x), x), 2*f(x)),
+ Eq(Derivative(g(x), x), f(x)),
+ Eq(Derivative(h(x), x), h(x)),
+ Eq(Derivative(k(x), x), f(x)**4 + k(x))]
+ sol2 = [Eq(f(x), C1*exp(2*x)),
+ Eq(g(x), C1*exp(2*x)/2 + C2),
+ Eq(h(x), C3*exp(x)),
+ Eq(k(x), C1**4*exp(8*x)/7 + C4*exp(x))]
+ assert dsolve(eqs2) == sol2
+ assert checksysodesol(eqs2, sol2) == (True, [0, 0, 0, 0])
+
+ components2 = {frozenset([(Eq(Derivative(f(x), x), 2*f(x)),),
+ (Eq(Derivative(g(x), x), f(x)),),
+ (Eq(Derivative(k(x), x), f(x)**4 + k(x)),)]),
+ frozenset([(Eq(Derivative(h(x), x), h(x)),)])}
+ eqsdict2 = ({f(x): set(), g(x): {f(x)}, h(x): set(), k(x): {f(x)}},
+ {f(x): Eq(Derivative(f(x), x), 2*f(x)),
+ g(x): Eq(Derivative(g(x), x), f(x)),
+ h(x): Eq(Derivative(h(x), x), h(x)),
+ k(x): Eq(Derivative(k(x), x), f(x)**4 + k(x))})
+ graph2 = [{f(x), g(x), h(x), k(x)}, {(g(x), f(x)), (k(x), f(x))}]
+ assert {frozenset(tuple(scc) for scc in wcc) for wcc in _component_division(eqs2, funcs, x)} == components2
+ assert _eqs2dict(eqs2, funcs) == eqsdict2
+ assert [set(element) for element in _dict2graph(eqsdict2[0])] == graph2
+
+ eqs3 = [Eq(Derivative(f(x), x), 2*f(x)),
+ Eq(Derivative(g(x), x), x + f(x)),
+ Eq(Derivative(h(x), x), h(x)),
+ Eq(Derivative(k(x), x), f(x)**4 + k(x))]
+ sol3 = [Eq(f(x), C1*exp(2*x)),
+ Eq(g(x), C1*exp(2*x)/2 + C2 + x**2/2),
+ Eq(h(x), C3*exp(x)),
+ Eq(k(x), C1**4*exp(8*x)/7 + C4*exp(x))]
+ assert dsolve(eqs3) == sol3
+ assert checksysodesol(eqs3, sol3) == (True, [0, 0, 0, 0])
+
+ components3 = {frozenset([(Eq(Derivative(f(x), x), 2*f(x)),),
+ (Eq(Derivative(g(x), x), x + f(x)),),
+ (Eq(Derivative(k(x), x), f(x)**4 + k(x)),)]),
+ frozenset([(Eq(Derivative(h(x), x), h(x)),),])}
+ eqsdict3 = ({f(x): set(), g(x): {f(x)}, h(x): set(), k(x): {f(x)}},
+ {f(x): Eq(Derivative(f(x), x), 2*f(x)),
+ g(x): Eq(Derivative(g(x), x), x + f(x)),
+ h(x): Eq(Derivative(h(x), x), h(x)),
+ k(x): Eq(Derivative(k(x), x), f(x)**4 + k(x))})
+ graph3 = [{f(x), g(x), h(x), k(x)}, {(g(x), f(x)), (k(x), f(x))}]
+ assert {frozenset(tuple(scc) for scc in wcc) for wcc in _component_division(eqs3, funcs, x)} == components3
+ assert _eqs2dict(eqs3, funcs) == eqsdict3
+ assert [set(l) for l in _dict2graph(eqsdict3[0])] == graph3
+
+ # Note: To be uncommented when the default option to call dsolve first for
+ # single ODE system can be rearranged. This can be done after the doit
+ # option in dsolve is made False by default.
+
+ eqs4 = [Eq(Derivative(f(x), x), x*f(x) + 2*g(x)),
+ Eq(Derivative(g(x), x), f(x) + x*g(x) + x),
+ Eq(Derivative(h(x), x), h(x)),
+ Eq(Derivative(k(x), x), f(x)**4 + k(x))]
+ sol4 = [Eq(f(x), (C1/2 - sqrt(2)*C2/2 - sqrt(2)*Integral(x*exp(-x**2/2 - sqrt(2)*x)/2 + x*exp(-x**2/2 +\
+ sqrt(2)*x)/2, x)/2 + Integral(sqrt(2)*x*exp(-x**2/2 - sqrt(2)*x)/2 - sqrt(2)*x*exp(-x**2/2 +\
+ sqrt(2)*x)/2, x)/2)*exp(x**2/2 - sqrt(2)*x) + (C1/2 + sqrt(2)*C2/2 + sqrt(2)*Integral(x*exp(-x**2/2
+ - sqrt(2)*x)/2 + x*exp(-x**2/2 + sqrt(2)*x)/2, x)/2 + Integral(sqrt(2)*x*exp(-x**2/2 - sqrt(2)*x)/2
+ - sqrt(2)*x*exp(-x**2/2 + sqrt(2)*x)/2, x)/2)*exp(x**2/2 + sqrt(2)*x)),
+ Eq(g(x), (-sqrt(2)*C1/4 + C2/2 + Integral(x*exp(-x**2/2 - sqrt(2)*x)/2 + x*exp(-x**2/2 + sqrt(2)*x)/2, x)/2 -\
+ sqrt(2)*Integral(sqrt(2)*x*exp(-x**2/2 - sqrt(2)*x)/2 - sqrt(2)*x*exp(-x**2/2 + sqrt(2)*x)/2,
+ x)/4)*exp(x**2/2 - sqrt(2)*x) + (sqrt(2)*C1/4 + C2/2 + Integral(x*exp(-x**2/2 - sqrt(2)*x)/2 +
+ x*exp(-x**2/2 + sqrt(2)*x)/2, x)/2 + sqrt(2)*Integral(sqrt(2)*x*exp(-x**2/2 - sqrt(2)*x)/2 -
+ sqrt(2)*x*exp(-x**2/2 + sqrt(2)*x)/2, x)/4)*exp(x**2/2 + sqrt(2)*x)),
+ Eq(h(x), C3*exp(x)),
+ Eq(k(x), C4*exp(x) + exp(x)*Integral((C1*exp(x**2/2 - sqrt(2)*x)/2 + C1*exp(x**2/2 + sqrt(2)*x)/2 -
+ sqrt(2)*C2*exp(x**2/2 - sqrt(2)*x)/2 + sqrt(2)*C2*exp(x**2/2 + sqrt(2)*x)/2 - sqrt(2)*exp(x**2/2 -
+ sqrt(2)*x)*Integral(x*exp(-x**2/2 - sqrt(2)*x)/2 + x*exp(-x**2/2 + sqrt(2)*x)/2, x)/2 + exp(x**2/2 -
+ sqrt(2)*x)*Integral(sqrt(2)*x*exp(-x**2/2 - sqrt(2)*x)/2 - sqrt(2)*x*exp(-x**2/2 + sqrt(2)*x)/2,
+ x)/2 + sqrt(2)*exp(x**2/2 + sqrt(2)*x)*Integral(x*exp(-x**2/2 - sqrt(2)*x)/2 + x*exp(-x**2/2 +
+ sqrt(2)*x)/2, x)/2 + exp(x**2/2 + sqrt(2)*x)*Integral(sqrt(2)*x*exp(-x**2/2 - sqrt(2)*x)/2 -
+ sqrt(2)*x*exp(-x**2/2 + sqrt(2)*x)/2, x)/2)**4*exp(-x), x))]
+ components4 = {(frozenset([Eq(Derivative(f(x), x), x*f(x) + 2*g(x)),
+ Eq(Derivative(g(x), x), x*g(x) + x + f(x))]),
+ frozenset([Eq(Derivative(k(x), x), f(x)**4 + k(x)),])),
+ (frozenset([Eq(Derivative(h(x), x), h(x)),]),)}
+ eqsdict4 = ({f(x): {g(x)}, g(x): {f(x)}, h(x): set(), k(x): {f(x)}},
+ {f(x): Eq(Derivative(f(x), x), x*f(x) + 2*g(x)),
+ g(x): Eq(Derivative(g(x), x), x*g(x) + x + f(x)),
+ h(x): Eq(Derivative(h(x), x), h(x)),
+ k(x): Eq(Derivative(k(x), x), f(x)**4 + k(x))})
+ graph4 = [{f(x), g(x), h(x), k(x)}, {(f(x), g(x)), (g(x), f(x)), (k(x), f(x))}]
+ assert {tuple(frozenset(scc) for scc in wcc) for wcc in _component_division(eqs4, funcs, x)} == components4
+ assert _eqs2dict(eqs4, funcs) == eqsdict4
+ assert [set(element) for element in _dict2graph(eqsdict4[0])] == graph4
+ # XXX: dsolve hangs in integration here:
+ assert dsolve_system(eqs4, simplify=False, doit=False) == [sol4]
+ assert checksysodesol(eqs4, sol4) == (True, [0, 0, 0, 0])
+
+ eqs5 = [Eq(Derivative(f(x), x), x*f(x) + 2*g(x)),
+ Eq(Derivative(g(x), x), x*g(x) + f(x)),
+ Eq(Derivative(h(x), x), h(x)),
+ Eq(Derivative(k(x), x), f(x)**4 + k(x))]
+ sol5 = [Eq(f(x), (C1/2 - sqrt(2)*C2/2)*exp(x**2/2 - sqrt(2)*x) + (C1/2 + sqrt(2)*C2/2)*exp(x**2/2 + sqrt(2)*x)),
+ Eq(g(x), (-sqrt(2)*C1/4 + C2/2)*exp(x**2/2 - sqrt(2)*x) + (sqrt(2)*C1/4 + C2/2)*exp(x**2/2 + sqrt(2)*x)),
+ Eq(h(x), C3*exp(x)),
+ Eq(k(x), C4*exp(x) + exp(x)*Integral((C1*exp(x**2/2 - sqrt(2)*x)/2 + C1*exp(x**2/2 + sqrt(2)*x)/2 -
+ sqrt(2)*C2*exp(x**2/2 - sqrt(2)*x)/2 + sqrt(2)*C2*exp(x**2/2 + sqrt(2)*x)/2)**4*exp(-x), x))]
+ components5 = {(frozenset([Eq(Derivative(f(x), x), x*f(x) + 2*g(x)),
+ Eq(Derivative(g(x), x), x*g(x) + f(x))]),
+ frozenset([Eq(Derivative(k(x), x), f(x)**4 + k(x)),])),
+ (frozenset([Eq(Derivative(h(x), x), h(x)),]),)}
+ eqsdict5 = ({f(x): {g(x)}, g(x): {f(x)}, h(x): set(), k(x): {f(x)}},
+ {f(x): Eq(Derivative(f(x), x), x*f(x) + 2*g(x)),
+ g(x): Eq(Derivative(g(x), x), x*g(x) + f(x)),
+ h(x): Eq(Derivative(h(x), x), h(x)),
+ k(x): Eq(Derivative(k(x), x), f(x)**4 + k(x))})
+ graph5 = [{f(x), g(x), h(x), k(x)}, {(f(x), g(x)), (g(x), f(x)), (k(x), f(x))}]
+ assert {tuple(frozenset(scc) for scc in wcc) for wcc in _component_division(eqs5, funcs, x)} == components5
+ assert _eqs2dict(eqs5, funcs) == eqsdict5
+ assert [set(element) for element in _dict2graph(eqsdict5[0])] == graph5
+ # XXX: dsolve hangs in integration here:
+ assert dsolve_system(eqs5, simplify=False, doit=False) == [sol5]
+ assert checksysodesol(eqs5, sol5) == (True, [0, 0, 0, 0])
+
+
+def test_linodesolve():
+ t, x, a = symbols("t x a")
+ f, g, h = symbols("f g h", cls=Function)
+
+ # Testing the Errors
+ raises(ValueError, lambda: linodesolve(1, t))
+ raises(ValueError, lambda: linodesolve(a, t))
+
+ A1 = Matrix([[1, 2], [2, 4], [4, 6]])
+ raises(NonSquareMatrixError, lambda: linodesolve(A1, t))
+
+ A2 = Matrix([[1, 2, 1], [3, 1, 2]])
+ raises(NonSquareMatrixError, lambda: linodesolve(A2, t))
+
+ # Testing auto functionality
+ func = [f(t), g(t)]
+ eq = [Eq(f(t).diff(t) + g(t).diff(t), g(t)), Eq(g(t).diff(t), f(t))]
+ ceq = canonical_odes(eq, func, t)
+ (A1, A0), b = linear_ode_to_matrix(ceq[0], func, t, 1)
+ A = A0
+ sol = [C1*(-Rational(1, 2) + sqrt(5)/2)*exp(t*(-Rational(1, 2) + sqrt(5)/2)) + C2*(-sqrt(5)/2 - Rational(1, 2))*
+ exp(t*(-sqrt(5)/2 - Rational(1, 2))),
+ C1*exp(t*(-Rational(1, 2) + sqrt(5)/2)) + C2*exp(t*(-sqrt(5)/2 - Rational(1, 2)))]
+ assert constant_renumber(linodesolve(A, t), variables=Tuple(*eq).free_symbols) == sol
+
+ # Testing the Errors
+ raises(ValueError, lambda: linodesolve(1, t, b=Matrix([t+1])))
+ raises(ValueError, lambda: linodesolve(a, t, b=Matrix([log(t) + sin(t)])))
+
+ raises(ValueError, lambda: linodesolve(Matrix([7]), t, b=t**2))
+ raises(ValueError, lambda: linodesolve(Matrix([a+10]), t, b=log(t)*cos(t)))
+
+ raises(ValueError, lambda: linodesolve(7, t, b=t**2))
+ raises(ValueError, lambda: linodesolve(a, t, b=log(t) + sin(t)))
+
+ A1 = Matrix([[1, 2], [2, 4], [4, 6]])
+ b1 = Matrix([t, 1, t**2])
+ raises(NonSquareMatrixError, lambda: linodesolve(A1, t, b=b1))
+
+ A2 = Matrix([[1, 2, 1], [3, 1, 2]])
+ b2 = Matrix([t, t**2])
+ raises(NonSquareMatrixError, lambda: linodesolve(A2, t, b=b2))
+
+ raises(ValueError, lambda: linodesolve(A1[:2, :], t, b=b1))
+ raises(ValueError, lambda: linodesolve(A1[:2, :], t, b=b1[:1]))
+
+ # DOIT check
+ A1 = Matrix([[1, -1], [1, -1]])
+ b1 = Matrix([15*t - 10, -15*t - 5])
+ sol1 = [C1 + C2*t + C2 - 10*t**3 + 10*t**2 + t*(15*t**2 - 5*t) - 10*t,
+ C1 + C2*t - 10*t**3 - 5*t**2 + t*(15*t**2 - 5*t) - 5*t]
+ assert constant_renumber(linodesolve(A1, t, b=b1, type="type2", doit=True),
+ variables=[t]) == sol1
+
+ # Testing auto functionality
+ func = [f(t), g(t)]
+ eq = [Eq(f(t).diff(t) + g(t).diff(t), g(t) + t), Eq(g(t).diff(t), f(t))]
+ ceq = canonical_odes(eq, func, t)
+ (A1, A0), b = linear_ode_to_matrix(ceq[0], func, t, 1)
+ A = A0
+ sol = [-C1*exp(-t/2 + sqrt(5)*t/2)/2 + sqrt(5)*C1*exp(-t/2 + sqrt(5)*t/2)/2 - sqrt(5)*C2*exp(-sqrt(5)*t/2 -
+ t/2)/2 - C2*exp(-sqrt(5)*t/2 - t/2)/2 - exp(-t/2 + sqrt(5)*t/2)*Integral(t*exp(-sqrt(5)*t/2 +
+ t/2)/(-5 + sqrt(5)) - sqrt(5)*t*exp(-sqrt(5)*t/2 + t/2)/(-5 + sqrt(5)), t)/2 + sqrt(5)*exp(-t/2 +
+ sqrt(5)*t/2)*Integral(t*exp(-sqrt(5)*t/2 + t/2)/(-5 + sqrt(5)) - sqrt(5)*t*exp(-sqrt(5)*t/2 +
+ t/2)/(-5 + sqrt(5)), t)/2 - sqrt(5)*exp(-sqrt(5)*t/2 - t/2)*Integral(-sqrt(5)*t*exp(t/2 +
+ sqrt(5)*t/2)/5, t)/2 - exp(-sqrt(5)*t/2 - t/2)*Integral(-sqrt(5)*t*exp(t/2 + sqrt(5)*t/2)/5, t)/2,
+ C1*exp(-t/2 + sqrt(5)*t/2) + C2*exp(-sqrt(5)*t/2 - t/2) + exp(-t/2 +
+ sqrt(5)*t/2)*Integral(t*exp(-sqrt(5)*t/2 + t/2)/(-5 + sqrt(5)) - sqrt(5)*t*exp(-sqrt(5)*t/2 +
+ t/2)/(-5 + sqrt(5)), t) + exp(-sqrt(5)*t/2 -
+ t/2)*Integral(-sqrt(5)*t*exp(t/2 + sqrt(5)*t/2)/5, t)]
+ assert constant_renumber(linodesolve(A, t, b=b), variables=[t]) == sol
+
+ # non-homogeneous term assumed to be 0
+ sol1 = [-C1*exp(-t/2 + sqrt(5)*t/2)/2 + sqrt(5)*C1*exp(-t/2 + sqrt(5)*t/2)/2 - sqrt(5)*C2*exp(-sqrt(5)*t/2
+ - t/2)/2 - C2*exp(-sqrt(5)*t/2 - t/2)/2,
+ C1*exp(-t/2 + sqrt(5)*t/2) + C2*exp(-sqrt(5)*t/2 - t/2)]
+ assert constant_renumber(linodesolve(A, t, type="type2"), variables=[t]) == sol1
+
+ # Testing the Errors
+ raises(ValueError, lambda: linodesolve(t+10, t))
+ raises(ValueError, lambda: linodesolve(a*t, t))
+
+ A1 = Matrix([[1, t], [-t, 1]])
+ B1, _ = _is_commutative_anti_derivative(A1, t)
+ raises(NonSquareMatrixError, lambda: linodesolve(A1[:, :1], t, B=B1))
+ raises(ValueError, lambda: linodesolve(A1, t, B=1))
+
+ A2 = Matrix([[t, t, t], [t, t, t], [t, t, t]])
+ B2, _ = _is_commutative_anti_derivative(A2, t)
+ raises(NonSquareMatrixError, lambda: linodesolve(A2, t, B=B2[:2, :]))
+ raises(ValueError, lambda: linodesolve(A2, t, B=2))
+ raises(ValueError, lambda: linodesolve(A2, t, B=B2, type="type31"))
+
+ raises(ValueError, lambda: linodesolve(A1, t, B=B2))
+ raises(ValueError, lambda: linodesolve(A2, t, B=B1))
+
+ # Testing auto functionality
+ func = [f(t), g(t)]
+ eq = [Eq(f(t).diff(t), f(t) + t*g(t)), Eq(g(t).diff(t), -t*f(t) + g(t))]
+ ceq = canonical_odes(eq, func, t)
+ (A1, A0), b = linear_ode_to_matrix(ceq[0], func, t, 1)
+ A = A0
+ sol = [(C1/2 - I*C2/2)*exp(I*t**2/2 + t) + (C1/2 + I*C2/2)*exp(-I*t**2/2 + t),
+ (-I*C1/2 + C2/2)*exp(-I*t**2/2 + t) + (I*C1/2 + C2/2)*exp(I*t**2/2 + t)]
+ assert constant_renumber(linodesolve(A, t), variables=Tuple(*eq).free_symbols) == sol
+ assert constant_renumber(linodesolve(A, t, type="type3"), variables=Tuple(*eq).free_symbols) == sol
+
+ A1 = Matrix([[t, 1], [t, -1]])
+ raises(NotImplementedError, lambda: linodesolve(A1, t))
+
+ # Testing the Errors
+ raises(ValueError, lambda: linodesolve(t+10, t, b=Matrix([t+1])))
+ raises(ValueError, lambda: linodesolve(a*t, t, b=Matrix([log(t) + sin(t)])))
+
+ raises(ValueError, lambda: linodesolve(Matrix([7*t]), t, b=t**2))
+ raises(ValueError, lambda: linodesolve(Matrix([a + 10*log(t)]), t, b=log(t)*cos(t)))
+
+ raises(ValueError, lambda: linodesolve(7*t, t, b=t**2))
+ raises(ValueError, lambda: linodesolve(a*t**2, t, b=log(t) + sin(t)))
+
+ A1 = Matrix([[1, t], [-t, 1]])
+ b1 = Matrix([t, t ** 2])
+ B1, _ = _is_commutative_anti_derivative(A1, t)
+ raises(NonSquareMatrixError, lambda: linodesolve(A1[:, :1], t, b=b1))
+
+ A2 = Matrix([[t, t, t], [t, t, t], [t, t, t]])
+ b2 = Matrix([t, 1, t**2])
+ B2, _ = _is_commutative_anti_derivative(A2, t)
+ raises(NonSquareMatrixError, lambda: linodesolve(A2[:2, :], t, b=b2))
+
+ raises(ValueError, lambda: linodesolve(A1, t, b=b2))
+ raises(ValueError, lambda: linodesolve(A2, t, b=b1))
+
+ raises(ValueError, lambda: linodesolve(A1, t, b=b1, B=B2))
+ raises(ValueError, lambda: linodesolve(A2, t, b=b2, B=B1))
+
+ # Testing auto functionality
+ func = [f(x), g(x), h(x)]
+ eq = [Eq(f(x).diff(x), x*(f(x) + g(x) + h(x)) + x),
+ Eq(g(x).diff(x), x*(f(x) + g(x) + h(x)) + x),
+ Eq(h(x).diff(x), x*(f(x) + g(x) + h(x)) + 1)]
+ ceq = canonical_odes(eq, func, x)
+ (A1, A0), b = linear_ode_to_matrix(ceq[0], func, x, 1)
+ A = A0
+ _x1 = exp(-3*x**2/2)
+ _x2 = exp(3*x**2/2)
+ _x3 = Integral(2*_x1*x/3 + _x1/3 + x/3 - Rational(1, 3), x)
+ _x4 = 2*_x2*_x3/3
+ _x5 = Integral(2*_x1*x/3 + _x1/3 - 2*x/3 + Rational(2, 3), x)
+ sol = [
+ C1*_x2/3 - C1/3 + C2*_x2/3 - C2/3 + C3*_x2/3 + 2*C3/3 + _x2*_x5/3 + _x3/3 + _x4 - _x5/3,
+ C1*_x2/3 + 2*C1/3 + C2*_x2/3 - C2/3 + C3*_x2/3 - C3/3 + _x2*_x5/3 + _x3/3 + _x4 - _x5/3,
+ C1*_x2/3 - C1/3 + C2*_x2/3 + 2*C2/3 + C3*_x2/3 - C3/3 + _x2*_x5/3 - 2*_x3/3 + _x4 + 2*_x5/3,
+ ]
+ assert constant_renumber(linodesolve(A, x, b=b), variables=Tuple(*eq).free_symbols) == sol
+ assert constant_renumber(linodesolve(A, x, b=b, type="type4"),
+ variables=Tuple(*eq).free_symbols) == sol
+
+ A1 = Matrix([[t, 1], [t, -1]])
+ raises(NotImplementedError, lambda: linodesolve(A1, t, b=b1))
+
+ # non-homogeneous term not passed
+ sol1 = [-C1/3 - C2/3 + 2*C3/3 + (C1/3 + C2/3 + C3/3)*exp(3*x**2/2), 2*C1/3 - C2/3 - C3/3 + (C1/3 + C2/3 + C3/3)*exp(3*x**2/2),
+ -C1/3 + 2*C2/3 - C3/3 + (C1/3 + C2/3 + C3/3)*exp(3*x**2/2)]
+ assert constant_renumber(linodesolve(A, x, type="type4", doit=True), variables=Tuple(*eq).free_symbols) == sol1
+
+
+@slow
+def test_linear_3eq_order1_type4_slow():
+ x, y, z = symbols('x, y, z', cls=Function)
+ t = Symbol('t')
+
+ f = t ** 3 + log(t)
+ g = t ** 2 + sin(t)
+ eq1 = (Eq(diff(x(t), t), (4 * f + g) * x(t) - f * y(t) - 2 * f * z(t)),
+ Eq(diff(y(t), t), 2 * f * x(t) + (f + g) * y(t) - 2 * f * z(t)), Eq(diff(z(t), t), 5 * f * x(t) + f * y(
+ t) + (-3 * f + g) * z(t)))
+ with dotprodsimp(True):
+ dsolve(eq1)
+
+
+@slow
+def test_linear_neq_order1_type2_slow1():
+ i, r1, c1, r2, c2, t = symbols('i, r1, c1, r2, c2, t')
+ x1 = Function('x1')
+ x2 = Function('x2')
+
+ eq1 = r1*c1*Derivative(x1(t), t) + x1(t) - x2(t) - r1*i
+ eq2 = r2*c1*Derivative(x1(t), t) + r2*c2*Derivative(x2(t), t) + x2(t) - r2*i
+ eq = [eq1, eq2]
+
+ # XXX: Solution is too complicated
+ [sol] = dsolve_system(eq, simplify=False, doit=False)
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+
+# Regression test case for issue #9204
+# https://github.com/sympy/sympy/issues/9204
+@slow
+def test_linear_new_order1_type2_de_lorentz_slow_check():
+ if ON_CI:
+ skip("Too slow for CI.")
+
+ m = Symbol("m", real=True)
+ q = Symbol("q", real=True)
+ t = Symbol("t", real=True)
+
+ e1, e2, e3 = symbols("e1:4", real=True)
+ b1, b2, b3 = symbols("b1:4", real=True)
+ v1, v2, v3 = symbols("v1:4", cls=Function, real=True)
+
+ eqs = [
+ -e1*q + m*Derivative(v1(t), t) - q*(-b2*v3(t) + b3*v2(t)),
+ -e2*q + m*Derivative(v2(t), t) - q*(b1*v3(t) - b3*v1(t)),
+ -e3*q + m*Derivative(v3(t), t) - q*(-b1*v2(t) + b2*v1(t))
+ ]
+ sol = dsolve(eqs)
+ assert checksysodesol(eqs, sol) == (True, [0, 0, 0])
+
+
+# Regression test case for issue #14001
+# https://github.com/sympy/sympy/issues/14001
+@slow
+def test_linear_neq_order1_type2_slow_check():
+ RC, t, C, Vs, L, R1, V0, I0 = symbols("RC t C Vs L R1 V0 I0")
+ V = Function("V")
+ I = Function("I")
+ system = [Eq(V(t).diff(t), -1/RC*V(t) + I(t)/C), Eq(I(t).diff(t), -R1/L*I(t) - 1/L*V(t) + Vs/L)]
+ [sol] = dsolve_system(system, simplify=False, doit=False)
+
+ assert checksysodesol(system, sol) == (True, [0, 0])
+
+
+def _linear_3eq_order1_type4_long():
+ x, y, z = symbols('x, y, z', cls=Function)
+ t = Symbol('t')
+
+ f = t ** 3 + log(t)
+ g = t ** 2 + sin(t)
+
+ eq1 = (Eq(diff(x(t), t), (4*f + g)*x(t) - f*y(t) - 2*f*z(t)),
+ Eq(diff(y(t), t), 2*f*x(t) + (f + g)*y(t) - 2*f*z(t)), Eq(diff(z(t), t), 5*f*x(t) + f*y(
+ t) + (-3*f + g)*z(t)))
+
+ dsolve_sol = dsolve(eq1)
+ dsolve_sol1 = [_simpsol(sol) for sol in dsolve_sol]
+
+ x_1 = sqrt(-t**6 - 8*t**3*log(t) + 8*t**3 - 16*log(t)**2 + 32*log(t) - 16)
+ x_2 = sqrt(3)
+ x_3 = 8324372644*C1*x_1*x_2 + 4162186322*C2*x_1*x_2 - 8324372644*C3*x_1*x_2
+ x_4 = 1 / (1903457163*t**3 + 3825881643*x_1*x_2 + 7613828652*log(t) - 7613828652)
+ x_5 = exp(t**3/3 + t*x_1*x_2/4 - cos(t))
+ x_6 = exp(t**3/3 - t*x_1*x_2/4 - cos(t))
+ x_7 = exp(t**4/2 + t**3/3 + 2*t*log(t) - 2*t - cos(t))
+ x_8 = 91238*C1*x_1*x_2 + 91238*C2*x_1*x_2 - 91238*C3*x_1*x_2
+ x_9 = 1 / (66049*t**3 - 50629*x_1*x_2 + 264196*log(t) - 264196)
+ x_10 = 50629 * C1 / 25189 + 37909*C2/25189 - 50629*C3/25189 - x_3*x_4
+ x_11 = -50629*C1/25189 - 12720*C2/25189 + 50629*C3/25189 + x_3*x_4
+ sol = [Eq(x(t), x_10*x_5 + x_11*x_6 + x_7*(C1 - C2)), Eq(y(t), x_10*x_5 + x_11*x_6), Eq(z(t), x_5*(
+ -424*C1/257 - 167*C2/257 + 424*C3/257 - x_8*x_9) + x_6*(167*C1/257 + 424*C2/257 -
+ 167*C3/257 + x_8*x_9) + x_7*(C1 - C2))]
+
+ assert dsolve_sol1 == sol
+ assert checksysodesol(eq1, dsolve_sol1) == (True, [0, 0, 0])
+
+
+@slow
+def test_neq_order1_type4_slow_check1():
+ f, g = symbols("f g", cls=Function)
+ x = symbols("x")
+
+ eqs = [Eq(diff(f(x), x), x*f(x) + x**2*g(x) + x),
+ Eq(diff(g(x), x), 2*x**2*f(x) + (x + 3*x**2)*g(x) + 1)]
+ sol = dsolve(eqs)
+ assert checksysodesol(eqs, sol) == (True, [0, 0])
+
+
+@slow
+def test_neq_order1_type4_slow_check2():
+ f, g, h = symbols("f, g, h", cls=Function)
+ x = Symbol("x")
+
+ eqs = [
+ Eq(Derivative(f(x), x), x*h(x) + f(x) + g(x) + 1),
+ Eq(Derivative(g(x), x), x*g(x) + f(x) + h(x) + 10),
+ Eq(Derivative(h(x), x), x*f(x) + x + g(x) + h(x))
+ ]
+ with dotprodsimp(True):
+ sol = dsolve(eqs)
+ assert checksysodesol(eqs, sol) == (True, [0, 0, 0])
+
+
+def _neq_order1_type4_slow3():
+ f, g = symbols("f g", cls=Function)
+ x = symbols("x")
+
+ eqs = [
+ Eq(Derivative(f(x), x), x*f(x) + g(x) + sin(x)),
+ Eq(Derivative(g(x), x), x**2 + x*g(x) - f(x))
+ ]
+ sol = [
+ Eq(f(x), (C1/2 - I*C2/2 - I*Integral(x**2*exp(-x**2/2 - I*x)/2 +
+ x**2*exp(-x**2/2 + I*x)/2 + I*exp(-x**2/2 - I*x)*sin(x)/2 -
+ I*exp(-x**2/2 + I*x)*sin(x)/2, x)/2 + Integral(-I*x**2*exp(-x**2/2
+ - I*x)/2 + I*x**2*exp(-x**2/2 + I*x)/2 + exp(-x**2/2 -
+ I*x)*sin(x)/2 + exp(-x**2/2 + I*x)*sin(x)/2, x)/2)*exp(x**2/2 +
+ I*x) + (C1/2 + I*C2/2 + I*Integral(x**2*exp(-x**2/2 - I*x)/2 +
+ x**2*exp(-x**2/2 + I*x)/2 + I*exp(-x**2/2 - I*x)*sin(x)/2 -
+ I*exp(-x**2/2 + I*x)*sin(x)/2, x)/2 + Integral(-I*x**2*exp(-x**2/2
+ - I*x)/2 + I*x**2*exp(-x**2/2 + I*x)/2 + exp(-x**2/2 -
+ I*x)*sin(x)/2 + exp(-x**2/2 + I*x)*sin(x)/2, x)/2)*exp(x**2/2 -
+ I*x)),
+ Eq(g(x), (-I*C1/2 + C2/2 + Integral(x**2*exp(-x**2/2 - I*x)/2 +
+ x**2*exp(-x**2/2 + I*x)/2 + I*exp(-x**2/2 - I*x)*sin(x)/2 -
+ I*exp(-x**2/2 + I*x)*sin(x)/2, x)/2 -
+ I*Integral(-I*x**2*exp(-x**2/2 - I*x)/2 + I*x**2*exp(-x**2/2 +
+ I*x)/2 + exp(-x**2/2 - I*x)*sin(x)/2 + exp(-x**2/2 +
+ I*x)*sin(x)/2, x)/2)*exp(x**2/2 - I*x) + (I*C1/2 + C2/2 +
+ Integral(x**2*exp(-x**2/2 - I*x)/2 + x**2*exp(-x**2/2 + I*x)/2 +
+ I*exp(-x**2/2 - I*x)*sin(x)/2 - I*exp(-x**2/2 + I*x)*sin(x)/2,
+ x)/2 + I*Integral(-I*x**2*exp(-x**2/2 - I*x)/2 +
+ I*x**2*exp(-x**2/2 + I*x)/2 + exp(-x**2/2 - I*x)*sin(x)/2 +
+ exp(-x**2/2 + I*x)*sin(x)/2, x)/2)*exp(x**2/2 + I*x))
+ ]
+
+ return eqs, sol
+
+
+def test_neq_order1_type4_slow3():
+ eqs, sol = _neq_order1_type4_slow3()
+ assert dsolve_system(eqs, simplify=False, doit=False) == [sol]
+ # XXX: dsolve gives an error in integration:
+ # assert dsolve(eqs) == sol
+ # https://github.com/sympy/sympy/issues/20155
+
+
+@slow
+def test_neq_order1_type4_slow_check3():
+ eqs, sol = _neq_order1_type4_slow3()
+ assert checksysodesol(eqs, sol) == (True, [0, 0])
+
+
+@XFAIL
+@slow
+def test_linear_3eq_order1_type4_long_dsolve_slow_xfail():
+ if ON_CI:
+ skip("Too slow for CI.")
+
+ eq, sol = _linear_3eq_order1_type4_long()
+
+ dsolve_sol = dsolve(eq)
+ dsolve_sol1 = [_simpsol(sol) for sol in dsolve_sol]
+
+ assert dsolve_sol1 == sol
+
+
+@slow
+def test_linear_3eq_order1_type4_long_dsolve_dotprodsimp():
+ if ON_CI:
+ skip("Too slow for CI.")
+
+ eq, sol = _linear_3eq_order1_type4_long()
+
+ # XXX: Only works with dotprodsimp see
+ # test_linear_3eq_order1_type4_long_dsolve_slow_xfail which is too slow
+ with dotprodsimp(True):
+ dsolve_sol = dsolve(eq)
+
+ dsolve_sol1 = [_simpsol(sol) for sol in dsolve_sol]
+ assert dsolve_sol1 == sol
+
+
+@slow
+def test_linear_3eq_order1_type4_long_check():
+ if ON_CI:
+ skip("Too slow for CI.")
+
+ eq, sol = _linear_3eq_order1_type4_long()
+ assert checksysodesol(eq, sol) == (True, [0, 0, 0])
+
+
+def test_dsolve_system():
+ f, g = symbols("f g", cls=Function)
+ x = symbols("x")
+ eqs = [Eq(f(x).diff(x), f(x) + g(x)), Eq(g(x).diff(x), f(x) + g(x))]
+ funcs = [f(x), g(x)]
+
+ sol = [[Eq(f(x), -C1 + C2*exp(2*x)), Eq(g(x), C1 + C2*exp(2*x))]]
+ assert dsolve_system(eqs, funcs=funcs, t=x, doit=True) == sol
+
+ raises(ValueError, lambda: dsolve_system(1))
+ raises(ValueError, lambda: dsolve_system(eqs, 1))
+ raises(ValueError, lambda: dsolve_system(eqs, funcs, 1))
+ raises(ValueError, lambda: dsolve_system(eqs, funcs[:1], x))
+
+ eq = (Eq(f(x).diff(x), 12 * f(x) - 6 * g(x)), Eq(g(x).diff(x) ** 2, 11 * f(x) + 3 * g(x)))
+ raises(NotImplementedError, lambda: dsolve_system(eq) == ([], []))
+
+ raises(NotImplementedError, lambda: dsolve_system(eq, funcs=[f(x), g(x)]) == ([], []))
+ raises(NotImplementedError, lambda: dsolve_system(eq, funcs=[f(x), g(x)], t=x) == ([], []))
+ raises(NotImplementedError, lambda: dsolve_system(eq, funcs=[f(x), g(x)], t=x, ics={f(0): 1, g(0): 1}) == ([], []))
+ raises(NotImplementedError, lambda: dsolve_system(eq, t=x, ics={f(0): 1, g(0): 1}) == ([], []))
+ raises(NotImplementedError, lambda: dsolve_system(eq, ics={f(0): 1, g(0): 1}) == ([], []))
+ raises(NotImplementedError, lambda: dsolve_system(eq, funcs=[f(x), g(x)], ics={f(0): 1, g(0): 1}) == ([], []))
+
+def test_dsolve():
+
+ f, g = symbols('f g', cls=Function)
+ x, y = symbols('x y')
+
+ eqs = [f(x).diff(x) - x, f(x).diff(x) + x]
+ with raises(ValueError):
+ dsolve(eqs)
+
+ eqs = [f(x, y).diff(x)]
+ with raises(ValueError):
+ dsolve(eqs)
+
+ eqs = [f(x, y).diff(x)+g(x).diff(x), g(x).diff(x)]
+ with raises(ValueError):
+ dsolve(eqs)
+
+
+@slow
+def test_higher_order1_slow1():
+ x, y = symbols("x y", cls=Function)
+ t = symbols("t")
+
+ eq = [
+ Eq(diff(x(t),t,t), (log(t)+t**2)*diff(x(t),t)+(log(t)+t**2)*3*diff(y(t),t)),
+ Eq(diff(y(t),t,t), (log(t)+t**2)*2*diff(x(t),t)+(log(t)+t**2)*9*diff(y(t),t))
+ ]
+ sol, = dsolve_system(eq, simplify=False, doit=False)
+ # The solution is too long to write out explicitly and checkodesol is too
+ # slow so we test for particular values of t:
+ for e in eq:
+ res = (e.lhs - e.rhs).subs({sol[0].lhs:sol[0].rhs, sol[1].lhs:sol[1].rhs})
+ res = res.subs({d: d.doit(deep=False) for d in res.atoms(Derivative)})
+ assert ratsimp(res.subs(t, 1)) == 0
+
+
+def test_second_order_type2_slow1():
+ x, y, z = symbols('x, y, z', cls=Function)
+ t, l = symbols('t, l')
+
+ eqs1 = [Eq(Derivative(x(t), (t, 2)), t*(2*x(t) + y(t))),
+ Eq(Derivative(y(t), (t, 2)), t*(-x(t) + 2*y(t)))]
+ sol1 = [Eq(x(t), I*C1*airyai(t*(2 - I)**(S(1)/3)) + I*C2*airybi(t*(2 - I)**(S(1)/3)) - I*C3*airyai(t*(2 +
+ I)**(S(1)/3)) - I*C4*airybi(t*(2 + I)**(S(1)/3))),
+ Eq(y(t), C1*airyai(t*(2 - I)**(S(1)/3)) + C2*airybi(t*(2 - I)**(S(1)/3)) + C3*airyai(t*(2 + I)**(S(1)/3)) +
+ C4*airybi(t*(2 + I)**(S(1)/3)))]
+ assert dsolve(eqs1) == sol1
+ assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+
+@slow
+@XFAIL
+def test_nonlinear_3eq_order1_type1():
+ if ON_CI:
+ skip("Too slow for CI.")
+ a, b, c = symbols('a b c')
+
+ eqs = [
+ a * f(x).diff(x) - (b - c) * g(x) * h(x),
+ b * g(x).diff(x) - (c - a) * h(x) * f(x),
+ c * h(x).diff(x) - (a - b) * f(x) * g(x),
+ ]
+
+ assert dsolve(eqs) # NotImplementedError
+
+
+@XFAIL
+def test_nonlinear_3eq_order1_type4():
+ eqs = [
+ Eq(f(x).diff(x), (2*h(x)*g(x) - 3*g(x)*h(x))),
+ Eq(g(x).diff(x), (4*f(x)*h(x) - 2*h(x)*f(x))),
+ Eq(h(x).diff(x), (3*g(x)*f(x) - 4*f(x)*g(x))),
+ ]
+ dsolve(eqs) # KeyError when matching
+ # sol = ?
+ # assert dsolve_sol == sol
+ # assert checksysodesol(eqs, dsolve_sol) == (True, [0, 0, 0])
+
+
+@slow
+@XFAIL
+def test_nonlinear_3eq_order1_type3():
+ if ON_CI:
+ skip("Too slow for CI.")
+ eqs = [
+ Eq(f(x).diff(x), (2*f(x)**2 - 3 )),
+ Eq(g(x).diff(x), (4 - 2*h(x) )),
+ Eq(h(x).diff(x), (3*h(x) - 4*f(x)**2)),
+ ]
+ dsolve(eqs) # Not sure if this finishes...
+ # sol = ?
+ # assert dsolve_sol == sol
+ # assert checksysodesol(eqs, dsolve_sol) == (True, [0, 0, 0])
+
+
+@XFAIL
+def test_nonlinear_3eq_order1_type5():
+ eqs = [
+ Eq(f(x).diff(x), f(x)*(2*f(x) - 3*g(x))),
+ Eq(g(x).diff(x), g(x)*(4*g(x) - 2*h(x))),
+ Eq(h(x).diff(x), h(x)*(3*h(x) - 4*f(x))),
+ ]
+ dsolve(eqs) # KeyError
+ # sol = ?
+ # assert dsolve_sol == sol
+ # assert checksysodesol(eqs, dsolve_sol) == (True, [0, 0, 0])
+
+
+def test_linear_2eq_order1():
+ x, y, z = symbols('x, y, z', cls=Function)
+ k, l, m, n = symbols('k, l, m, n', Integer=True)
+ t = Symbol('t')
+ x0, y0 = symbols('x0, y0', cls=Function)
+
+ eq1 = (Eq(diff(x(t),t), x(t) + y(t) + 9), Eq(diff(y(t),t), 2*x(t) + 5*y(t) + 23))
+ sol1 = [Eq(x(t), C1*exp(t*(sqrt(6) + 3)) + C2*exp(t*(-sqrt(6) + 3)) - Rational(22, 3)), \
+ Eq(y(t), C1*(2 + sqrt(6))*exp(t*(sqrt(6) + 3)) + C2*(-sqrt(6) + 2)*exp(t*(-sqrt(6) + 3)) - Rational(5, 3))]
+ assert checksysodesol(eq1, sol1) == (True, [0, 0])
+
+ eq2 = (Eq(diff(x(t),t), x(t) + y(t) + 81), Eq(diff(y(t),t), -2*x(t) + y(t) + 23))
+ sol2 = [Eq(x(t), (C1*cos(sqrt(2)*t) + C2*sin(sqrt(2)*t))*exp(t) - Rational(58, 3)), \
+ Eq(y(t), (-sqrt(2)*C1*sin(sqrt(2)*t) + sqrt(2)*C2*cos(sqrt(2)*t))*exp(t) - Rational(185, 3))]
+ assert checksysodesol(eq2, sol2) == (True, [0, 0])
+
+ eq3 = (Eq(diff(x(t),t), 5*t*x(t) + 2*y(t)), Eq(diff(y(t),t), 2*x(t) + 5*t*y(t)))
+ sol3 = [Eq(x(t), (C1*exp(2*t) + C2*exp(-2*t))*exp(Rational(5, 2)*t**2)), \
+ Eq(y(t), (C1*exp(2*t) - C2*exp(-2*t))*exp(Rational(5, 2)*t**2))]
+ assert checksysodesol(eq3, sol3) == (True, [0, 0])
+
+ eq4 = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t)), Eq(diff(y(t),t), -t**2*x(t) + 5*t*y(t)))
+ sol4 = [Eq(x(t), (C1*cos((t**3)/3) + C2*sin((t**3)/3))*exp(Rational(5, 2)*t**2)), \
+ Eq(y(t), (-C1*sin((t**3)/3) + C2*cos((t**3)/3))*exp(Rational(5, 2)*t**2))]
+ assert checksysodesol(eq4, sol4) == (True, [0, 0])
+
+ eq5 = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t)), Eq(diff(y(t),t), -t**2*x(t) + (5*t+9*t**2)*y(t)))
+ sol5 = [Eq(x(t), (C1*exp((sqrt(77)/2 + Rational(9, 2))*(t**3)/3) + \
+ C2*exp((-sqrt(77)/2 + Rational(9, 2))*(t**3)/3))*exp(Rational(5, 2)*t**2)), \
+ Eq(y(t), (C1*(sqrt(77)/2 + Rational(9, 2))*exp((sqrt(77)/2 + Rational(9, 2))*(t**3)/3) + \
+ C2*(-sqrt(77)/2 + Rational(9, 2))*exp((-sqrt(77)/2 + Rational(9, 2))*(t**3)/3))*exp(Rational(5, 2)*t**2))]
+ assert checksysodesol(eq5, sol5) == (True, [0, 0])
+
+ eq6 = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t)), Eq(diff(y(t),t), (1-t**2)*x(t) + (5*t+9*t**2)*y(t)))
+ sol6 = [Eq(x(t), C1*x0(t) + C2*x0(t)*Integral(t**2*exp(Integral(5*t, t))*exp(Integral(9*t**2 + 5*t, t))/x0(t)**2, t)), \
+ Eq(y(t), C1*y0(t) + C2*(y0(t)*Integral(t**2*exp(Integral(5*t, t))*exp(Integral(9*t**2 + 5*t, t))/x0(t)**2, t) + \
+ exp(Integral(5*t, t))*exp(Integral(9*t**2 + 5*t, t))/x0(t)))]
+ s = dsolve(eq6)
+ assert s == sol6 # too complicated to test with subs and simplify
+ # assert checksysodesol(eq10, sol10) == (True, [0, 0]) # this one fails
+
+
+def test_nonlinear_2eq_order1():
+ x, y, z = symbols('x, y, z', cls=Function)
+ t = Symbol('t')
+ eq1 = (Eq(diff(x(t),t),x(t)*y(t)**3), Eq(diff(y(t),t),y(t)**5))
+ sol1 = [
+ Eq(x(t), C1*exp((-1/(4*C2 + 4*t))**(Rational(-1, 4)))),
+ Eq(y(t), -(-1/(4*C2 + 4*t))**Rational(1, 4)),
+ Eq(x(t), C1*exp(-1/(-1/(4*C2 + 4*t))**Rational(1, 4))),
+ Eq(y(t), (-1/(4*C2 + 4*t))**Rational(1, 4)),
+ Eq(x(t), C1*exp(-I/(-1/(4*C2 + 4*t))**Rational(1, 4))),
+ Eq(y(t), -I*(-1/(4*C2 + 4*t))**Rational(1, 4)),
+ Eq(x(t), C1*exp(I/(-1/(4*C2 + 4*t))**Rational(1, 4))),
+ Eq(y(t), I*(-1/(4*C2 + 4*t))**Rational(1, 4))]
+ assert dsolve(eq1) == sol1
+ assert checksysodesol(eq1, sol1) == (True, [0, 0])
+
+ eq2 = (Eq(diff(x(t),t), exp(3*x(t))*y(t)**3),Eq(diff(y(t),t), y(t)**5))
+ sol2 = [
+ Eq(x(t), -log(C1 - 3/(-1/(4*C2 + 4*t))**Rational(1, 4))/3),
+ Eq(y(t), -(-1/(4*C2 + 4*t))**Rational(1, 4)),
+ Eq(x(t), -log(C1 + 3/(-1/(4*C2 + 4*t))**Rational(1, 4))/3),
+ Eq(y(t), (-1/(4*C2 + 4*t))**Rational(1, 4)),
+ Eq(x(t), -log(C1 + 3*I/(-1/(4*C2 + 4*t))**Rational(1, 4))/3),
+ Eq(y(t), -I*(-1/(4*C2 + 4*t))**Rational(1, 4)),
+ Eq(x(t), -log(C1 - 3*I/(-1/(4*C2 + 4*t))**Rational(1, 4))/3),
+ Eq(y(t), I*(-1/(4*C2 + 4*t))**Rational(1, 4))]
+ assert dsolve(eq2) == sol2
+ assert checksysodesol(eq2, sol2) == (True, [0, 0])
+
+ eq3 = (Eq(diff(x(t),t), y(t)*x(t)), Eq(diff(y(t),t), x(t)**3))
+ tt = Rational(2, 3)
+ sol3 = [
+ Eq(x(t), 6**tt/(6*(-sinh(sqrt(C1)*(C2 + t)/2)/sqrt(C1))**tt)),
+ Eq(y(t), sqrt(C1 + C1/sinh(sqrt(C1)*(C2 + t)/2)**2)/3)]
+ assert dsolve(eq3) == sol3
+ # FIXME: assert checksysodesol(eq3, sol3) == (True, [0, 0])
+
+ eq4 = (Eq(diff(x(t),t),x(t)*y(t)*sin(t)**2), Eq(diff(y(t),t),y(t)**2*sin(t)**2))
+ sol4 = {Eq(x(t), -2*exp(C1)/(C2*exp(C1) + t - sin(2*t)/2)), Eq(y(t), -2/(C1 + t - sin(2*t)/2))}
+ assert dsolve(eq4) == sol4
+ # FIXME: assert checksysodesol(eq4, sol4) == (True, [0, 0])
+
+ eq5 = (Eq(x(t),t*diff(x(t),t)+diff(x(t),t)*diff(y(t),t)), Eq(y(t),t*diff(y(t),t)+diff(y(t),t)**2))
+ sol5 = {Eq(x(t), C1*C2 + C1*t), Eq(y(t), C2**2 + C2*t)}
+ assert dsolve(eq5) == sol5
+ assert checksysodesol(eq5, sol5) == (True, [0, 0])
+
+ eq6 = (Eq(diff(x(t),t),x(t)**2*y(t)**3), Eq(diff(y(t),t),y(t)**5))
+ sol6 = [
+ Eq(x(t), 1/(C1 - 1/(-1/(4*C2 + 4*t))**Rational(1, 4))),
+ Eq(y(t), -(-1/(4*C2 + 4*t))**Rational(1, 4)),
+ Eq(x(t), 1/(C1 + (-1/(4*C2 + 4*t))**(Rational(-1, 4)))),
+ Eq(y(t), (-1/(4*C2 + 4*t))**Rational(1, 4)),
+ Eq(x(t), 1/(C1 + I/(-1/(4*C2 + 4*t))**Rational(1, 4))),
+ Eq(y(t), -I*(-1/(4*C2 + 4*t))**Rational(1, 4)),
+ Eq(x(t), 1/(C1 - I/(-1/(4*C2 + 4*t))**Rational(1, 4))),
+ Eq(y(t), I*(-1/(4*C2 + 4*t))**Rational(1, 4))]
+ assert dsolve(eq6) == sol6
+ assert checksysodesol(eq6, sol6) == (True, [0, 0])
+
+
+@slow
+def test_nonlinear_3eq_order1():
+ x, y, z = symbols('x, y, z', cls=Function)
+ t, u = symbols('t u')
+ eq1 = (4*diff(x(t),t) + 2*y(t)*z(t), 3*diff(y(t),t) - z(t)*x(t), 5*diff(z(t),t) - x(t)*y(t))
+ sol1 = [Eq(4*Integral(1/(sqrt(-4*u**2 - 3*C1 + C2)*sqrt(-4*u**2 + 5*C1 - C2)), (u, x(t))),
+ C3 - sqrt(15)*t/15), Eq(3*Integral(1/(sqrt(-6*u**2 - C1 + 5*C2)*sqrt(3*u**2 + C1 - 4*C2)),
+ (u, y(t))), C3 + sqrt(5)*t/10), Eq(5*Integral(1/(sqrt(-10*u**2 - 3*C1 + C2)*
+ sqrt(5*u**2 + 4*C1 - C2)), (u, z(t))), C3 + sqrt(3)*t/6)]
+ assert [i.dummy_eq(j) for i, j in zip(dsolve(eq1), sol1)]
+ # FIXME: assert checksysodesol(eq1, sol1) == (True, [0, 0, 0])
+
+ eq2 = (4*diff(x(t),t) + 2*y(t)*z(t)*sin(t), 3*diff(y(t),t) - z(t)*x(t)*sin(t), 5*diff(z(t),t) - x(t)*y(t)*sin(t))
+ sol2 = [Eq(3*Integral(1/(sqrt(-6*u**2 - C1 + 5*C2)*sqrt(3*u**2 + C1 - 4*C2)), (u, x(t))), C3 +
+ sqrt(5)*cos(t)/10), Eq(4*Integral(1/(sqrt(-4*u**2 - 3*C1 + C2)*sqrt(-4*u**2 + 5*C1 - C2)),
+ (u, y(t))), C3 - sqrt(15)*cos(t)/15), Eq(5*Integral(1/(sqrt(-10*u**2 - 3*C1 + C2)*
+ sqrt(5*u**2 + 4*C1 - C2)), (u, z(t))), C3 + sqrt(3)*cos(t)/6)]
+ assert [i.dummy_eq(j) for i, j in zip(dsolve(eq2), sol2)]
+ # FIXME: assert checksysodesol(eq2, sol2) == (True, [0, 0, 0])
+
+
+def test_C1_function_9239():
+ t = Symbol('t')
+ C1 = Function('C1')
+ C2 = Function('C2')
+ C3 = Symbol('C3')
+ C4 = Symbol('C4')
+ eq = (Eq(diff(C1(t), t), 9*C2(t)), Eq(diff(C2(t), t), 12*C1(t)))
+ sol = [Eq(C1(t), 9*C3*exp(6*sqrt(3)*t) + 9*C4*exp(-6*sqrt(3)*t)),
+ Eq(C2(t), 6*sqrt(3)*C3*exp(6*sqrt(3)*t) - 6*sqrt(3)*C4*exp(-6*sqrt(3)*t))]
+ assert checksysodesol(eq, sol) == (True, [0, 0])
+
+
+def test_dsolve_linsystem_symbol():
+ eps = Symbol('epsilon', positive=True)
+ eq1 = (Eq(diff(f(x), x), -eps*g(x)), Eq(diff(g(x), x), eps*f(x)))
+ sol1 = [Eq(f(x), -C1*eps*cos(eps*x) - C2*eps*sin(eps*x)),
+ Eq(g(x), -C1*eps*sin(eps*x) + C2*eps*cos(eps*x))]
+ assert checksysodesol(eq1, sol1) == (True, [0, 0])
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/pde.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/pde.py
new file mode 100644
index 0000000000000000000000000000000000000000..d12b3022d4f2dae3b99cac42fc7449b845dd31ea
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/pde.py
@@ -0,0 +1,1004 @@
+"""
+This module contains pdsolve() and different helper functions that it
+uses. It is heavily inspired by the ode module and hence the basic
+infrastructure remains the same.
+
+**Functions in this module**
+
+ These are the user functions in this module:
+
+ - pdsolve() - Solves PDE's
+ - classify_pde() - Classifies PDEs into possible hints for dsolve().
+ - pde_separate() - Separate variables in partial differential equation either by
+ additive or multiplicative separation approach.
+
+ These are the helper functions in this module:
+
+ - pde_separate_add() - Helper function for searching additive separable solutions.
+ - pde_separate_mul() - Helper function for searching multiplicative
+ separable solutions.
+
+**Currently implemented solver methods**
+
+The following methods are implemented for solving partial differential
+equations. See the docstrings of the various pde_hint() functions for
+more information on each (run help(pde)):
+
+ - 1st order linear homogeneous partial differential equations
+ with constant coefficients.
+ - 1st order linear general partial differential equations
+ with constant coefficients.
+ - 1st order linear partial differential equations with
+ variable coefficients.
+
+"""
+from functools import reduce
+
+from itertools import combinations_with_replacement
+from sympy.simplify import simplify # type: ignore
+from sympy.core import Add, S
+from sympy.core.function import Function, expand, AppliedUndef, Subs
+from sympy.core.relational import Equality, Eq
+from sympy.core.symbol import Symbol, Wild, symbols
+from sympy.functions import exp
+from sympy.integrals.integrals import Integral, integrate
+from sympy.utilities.iterables import has_dups, is_sequence
+from sympy.utilities.misc import filldedent
+
+from sympy.solvers.deutils import _preprocess, ode_order, _desolve
+from sympy.solvers.solvers import solve
+from sympy.simplify.radsimp import collect
+
+import operator
+
+
+allhints = (
+ "1st_linear_constant_coeff_homogeneous",
+ "1st_linear_constant_coeff",
+ "1st_linear_constant_coeff_Integral",
+ "1st_linear_variable_coeff"
+ )
+
+
+def pdsolve(eq, func=None, hint='default', dict=False, solvefun=None, **kwargs):
+ """
+ Solves any (supported) kind of partial differential equation.
+
+ **Usage**
+
+ pdsolve(eq, f(x,y), hint) -> Solve partial differential equation
+ eq for function f(x,y), using method hint.
+
+ **Details**
+
+ ``eq`` can be any supported partial differential equation (see
+ the pde docstring for supported methods). This can either
+ be an Equality, or an expression, which is assumed to be
+ equal to 0.
+
+ ``f(x,y)`` is a function of two variables whose derivatives in that
+ variable make up the partial differential equation. In many
+ cases it is not necessary to provide this; it will be autodetected
+ (and an error raised if it could not be detected).
+
+ ``hint`` is the solving method that you want pdsolve to use. Use
+ classify_pde(eq, f(x,y)) to get all of the possible hints for
+ a PDE. The default hint, 'default', will use whatever hint
+ is returned first by classify_pde(). See Hints below for
+ more options that you can use for hint.
+
+ ``solvefun`` is the convention used for arbitrary functions returned
+ by the PDE solver. If not set by the user, it is set by default
+ to be F.
+
+ **Hints**
+
+ Aside from the various solving methods, there are also some
+ meta-hints that you can pass to pdsolve():
+
+ "default":
+ This uses whatever hint is returned first by
+ classify_pde(). This is the default argument to
+ pdsolve().
+
+ "all":
+ To make pdsolve apply all relevant classification hints,
+ use pdsolve(PDE, func, hint="all"). This will return a
+ dictionary of hint:solution terms. If a hint causes
+ pdsolve to raise the NotImplementedError, value of that
+ hint's key will be the exception object raised. The
+ dictionary will also include some special keys:
+
+ - order: The order of the PDE. See also ode_order() in
+ deutils.py
+ - default: The solution that would be returned by
+ default. This is the one produced by the hint that
+ appears first in the tuple returned by classify_pde().
+
+ "all_Integral":
+ This is the same as "all", except if a hint also has a
+ corresponding "_Integral" hint, it only returns the
+ "_Integral" hint. This is useful if "all" causes
+ pdsolve() to hang because of a difficult or impossible
+ integral. This meta-hint will also be much faster than
+ "all", because integrate() is an expensive routine.
+
+ See also the classify_pde() docstring for more info on hints,
+ and the pde docstring for a list of all supported hints.
+
+ **Tips**
+ - You can declare the derivative of an unknown function this way:
+
+ >>> from sympy import Function, Derivative
+ >>> from sympy.abc import x, y # x and y are the independent variables
+ >>> f = Function("f")(x, y) # f is a function of x and y
+ >>> # fx will be the partial derivative of f with respect to x
+ >>> fx = Derivative(f, x)
+ >>> # fy will be the partial derivative of f with respect to y
+ >>> fy = Derivative(f, y)
+
+ - See test_pde.py for many tests, which serves also as a set of
+ examples for how to use pdsolve().
+ - pdsolve always returns an Equality class (except for the case
+ when the hint is "all" or "all_Integral"). Note that it is not possible
+ to get an explicit solution for f(x, y) as in the case of ODE's
+ - Do help(pde.pde_hintname) to get help more information on a
+ specific hint
+
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.pde import pdsolve
+ >>> from sympy import Function, Eq
+ >>> from sympy.abc import x, y
+ >>> f = Function('f')
+ >>> u = f(x, y)
+ >>> ux = u.diff(x)
+ >>> uy = u.diff(y)
+ >>> eq = Eq(1 + (2*(ux/u)) + (3*(uy/u)), 0)
+ >>> pdsolve(eq)
+ Eq(f(x, y), F(3*x - 2*y)*exp(-2*x/13 - 3*y/13))
+
+ """
+
+ if not solvefun:
+ solvefun = Function('F')
+
+ # See the docstring of _desolve for more details.
+ hints = _desolve(eq, func=func, hint=hint, simplify=True,
+ type='pde', **kwargs)
+ eq = hints.pop('eq', False)
+ all_ = hints.pop('all', False)
+
+ if all_:
+ # TODO : 'best' hint should be implemented when adequate
+ # number of hints are added.
+ pdedict = {}
+ failed_hints = {}
+ gethints = classify_pde(eq, dict=True)
+ pdedict.update({'order': gethints['order'],
+ 'default': gethints['default']})
+ for hint in hints:
+ try:
+ rv = _helper_simplify(eq, hint, hints[hint]['func'],
+ hints[hint]['order'], hints[hint][hint], solvefun)
+ except NotImplementedError as detail:
+ failed_hints[hint] = detail
+ else:
+ pdedict[hint] = rv
+ pdedict.update(failed_hints)
+ return pdedict
+
+ else:
+ return _helper_simplify(eq, hints['hint'], hints['func'],
+ hints['order'], hints[hints['hint']], solvefun)
+
+
+def _helper_simplify(eq, hint, func, order, match, solvefun):
+ """Helper function of pdsolve that calls the respective
+ pde functions to solve for the partial differential
+ equations. This minimizes the computation in
+ calling _desolve multiple times.
+ """
+
+ if hint.endswith("_Integral"):
+ solvefunc = globals()[
+ "pde_" + hint[:-len("_Integral")]]
+ else:
+ solvefunc = globals()["pde_" + hint]
+ return _handle_Integral(solvefunc(eq, func, order,
+ match, solvefun), func, order, hint)
+
+
+def _handle_Integral(expr, func, order, hint):
+ r"""
+ Converts a solution with integrals in it into an actual solution.
+
+ Simplifies the integral mainly using doit()
+ """
+ if hint.endswith("_Integral"):
+ return expr
+
+ elif hint == "1st_linear_constant_coeff":
+ return simplify(expr.doit())
+
+ else:
+ return expr
+
+
+def classify_pde(eq, func=None, dict=False, *, prep=True, **kwargs):
+ """
+ Returns a tuple of possible pdsolve() classifications for a PDE.
+
+ The tuple is ordered so that first item is the classification that
+ pdsolve() uses to solve the PDE by default. In general,
+ classifications near the beginning of the list will produce
+ better solutions faster than those near the end, though there are
+ always exceptions. To make pdsolve use a different classification,
+ use pdsolve(PDE, func, hint=). See also the pdsolve()
+ docstring for different meta-hints you can use.
+
+ If ``dict`` is true, classify_pde() will return a dictionary of
+ hint:match expression terms. This is intended for internal use by
+ pdsolve(). Note that because dictionaries are ordered arbitrarily,
+ this will most likely not be in the same order as the tuple.
+
+ You can get help on different hints by doing help(pde.pde_hintname),
+ where hintname is the name of the hint without "_Integral".
+
+ See sympy.pde.allhints or the sympy.pde docstring for a list of all
+ supported hints that can be returned from classify_pde.
+
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.pde import classify_pde
+ >>> from sympy import Function, Eq
+ >>> from sympy.abc import x, y
+ >>> f = Function('f')
+ >>> u = f(x, y)
+ >>> ux = u.diff(x)
+ >>> uy = u.diff(y)
+ >>> eq = Eq(1 + (2*(ux/u)) + (3*(uy/u)), 0)
+ >>> classify_pde(eq)
+ ('1st_linear_constant_coeff_homogeneous',)
+ """
+
+ if func and len(func.args) != 2:
+ raise NotImplementedError("Right now only partial "
+ "differential equations of two variables are supported")
+
+ if prep or func is None:
+ prep, func_ = _preprocess(eq, func)
+ if func is None:
+ func = func_
+
+ if isinstance(eq, Equality):
+ if eq.rhs != 0:
+ return classify_pde(eq.lhs - eq.rhs, func)
+ eq = eq.lhs
+
+ f = func.func
+ x = func.args[0]
+ y = func.args[1]
+ fx = f(x,y).diff(x)
+ fy = f(x,y).diff(y)
+
+ # TODO : For now pde.py uses support offered by the ode_order function
+ # to find the order with respect to a multi-variable function. An
+ # improvement could be to classify the order of the PDE on the basis of
+ # individual variables.
+ order = ode_order(eq, f(x,y))
+
+ # hint:matchdict or hint:(tuple of matchdicts)
+ # Also will contain "default": and "order":order items.
+ matching_hints = {'order': order}
+
+ if not order:
+ if dict:
+ matching_hints["default"] = None
+ return matching_hints
+ else:
+ return ()
+
+ eq = expand(eq)
+
+ a = Wild('a', exclude = [f(x,y)])
+ b = Wild('b', exclude = [f(x,y), fx, fy, x, y])
+ c = Wild('c', exclude = [f(x,y), fx, fy, x, y])
+ d = Wild('d', exclude = [f(x,y), fx, fy, x, y])
+ e = Wild('e', exclude = [f(x,y), fx, fy])
+ n = Wild('n', exclude = [x, y])
+ # Try removing the smallest power of f(x,y)
+ # from the highest partial derivatives of f(x,y)
+ reduced_eq = None
+ if eq.is_Add:
+ var = set(combinations_with_replacement((x,y), order))
+ dummyvar = var.copy()
+ power = None
+ for i in var:
+ coeff = eq.coeff(f(x,y).diff(*i))
+ if coeff != 1:
+ match = coeff.match(a*f(x,y)**n)
+ if match and match[a]:
+ power = match[n]
+ dummyvar.remove(i)
+ break
+ dummyvar.remove(i)
+ for i in dummyvar:
+ coeff = eq.coeff(f(x,y).diff(*i))
+ if coeff != 1:
+ match = coeff.match(a*f(x,y)**n)
+ if match and match[a] and match[n] < power:
+ power = match[n]
+ if power:
+ den = f(x,y)**power
+ reduced_eq = Add(*[arg/den for arg in eq.args])
+ if not reduced_eq:
+ reduced_eq = eq
+
+ if order == 1:
+ reduced_eq = collect(reduced_eq, f(x, y))
+ r = reduced_eq.match(b*fx + c*fy + d*f(x,y) + e)
+ if r:
+ if not r[e]:
+ ## Linear first-order homogeneous partial-differential
+ ## equation with constant coefficients
+ r.update({'b': b, 'c': c, 'd': d})
+ matching_hints["1st_linear_constant_coeff_homogeneous"] = r
+ else:
+ if r[b]**2 + r[c]**2 != 0:
+ ## Linear first-order general partial-differential
+ ## equation with constant coefficients
+ r.update({'b': b, 'c': c, 'd': d, 'e': e})
+ matching_hints["1st_linear_constant_coeff"] = r
+ matching_hints[
+ "1st_linear_constant_coeff_Integral"] = r
+
+ else:
+ b = Wild('b', exclude=[f(x, y), fx, fy])
+ c = Wild('c', exclude=[f(x, y), fx, fy])
+ d = Wild('d', exclude=[f(x, y), fx, fy])
+ r = reduced_eq.match(b*fx + c*fy + d*f(x,y) + e)
+ if r:
+ r.update({'b': b, 'c': c, 'd': d, 'e': e})
+ matching_hints["1st_linear_variable_coeff"] = r
+
+ # Order keys based on allhints.
+ retlist = [i for i in allhints if i in matching_hints]
+
+ if dict:
+ # Dictionaries are ordered arbitrarily, so make note of which
+ # hint would come first for pdsolve(). Use an ordered dict in Py 3.
+ matching_hints["default"] = None
+ matching_hints["ordered_hints"] = tuple(retlist)
+ for i in allhints:
+ if i in matching_hints:
+ matching_hints["default"] = i
+ break
+ return matching_hints
+ else:
+ return tuple(retlist)
+
+
+def checkpdesol(pde, sol, func=None, solve_for_func=True):
+ """
+ Checks if the given solution satisfies the partial differential
+ equation.
+
+ pde is the partial differential equation which can be given in the
+ form of an equation or an expression. sol is the solution for which
+ the pde is to be checked. This can also be given in an equation or
+ an expression form. If the function is not provided, the helper
+ function _preprocess from deutils is used to identify the function.
+
+ If a sequence of solutions is passed, the same sort of container will be
+ used to return the result for each solution.
+
+ The following methods are currently being implemented to check if the
+ solution satisfies the PDE:
+
+ 1. Directly substitute the solution in the PDE and check. If the
+ solution has not been solved for f, then it will solve for f
+ provided solve_for_func has not been set to False.
+
+ If the solution satisfies the PDE, then a tuple (True, 0) is returned.
+ Otherwise a tuple (False, expr) where expr is the value obtained
+ after substituting the solution in the PDE. However if a known solution
+ returns False, it may be due to the inability of doit() to simplify it to zero.
+
+ Examples
+ ========
+
+ >>> from sympy import Function, symbols
+ >>> from sympy.solvers.pde import checkpdesol, pdsolve
+ >>> x, y = symbols('x y')
+ >>> f = Function('f')
+ >>> eq = 2*f(x,y) + 3*f(x,y).diff(x) + 4*f(x,y).diff(y)
+ >>> sol = pdsolve(eq)
+ >>> assert checkpdesol(eq, sol)[0]
+ >>> eq = x*f(x,y) + f(x,y).diff(x)
+ >>> checkpdesol(eq, sol)
+ (False, (x*F(4*x - 3*y) - 6*F(4*x - 3*y)/25 + 4*Subs(Derivative(F(_xi_1), _xi_1), _xi_1, 4*x - 3*y))*exp(-6*x/25 - 8*y/25))
+ """
+
+ # Converting the pde into an equation
+ if not isinstance(pde, Equality):
+ pde = Eq(pde, 0)
+
+ # If no function is given, try finding the function present.
+ if func is None:
+ try:
+ _, func = _preprocess(pde.lhs)
+ except ValueError:
+ funcs = [s.atoms(AppliedUndef) for s in (
+ sol if is_sequence(sol, set) else [sol])]
+ funcs = set().union(funcs)
+ if len(funcs) != 1:
+ raise ValueError(
+ 'must pass func arg to checkpdesol for this case.')
+ func = funcs.pop()
+
+ # If the given solution is in the form of a list or a set
+ # then return a list or set of tuples.
+ if is_sequence(sol, set):
+ return type(sol)([checkpdesol(
+ pde, i, func=func,
+ solve_for_func=solve_for_func) for i in sol])
+
+ # Convert solution into an equation
+ if not isinstance(sol, Equality):
+ sol = Eq(func, sol)
+ elif sol.rhs == func:
+ sol = sol.reversed
+
+ # Try solving for the function
+ solved = sol.lhs == func and not sol.rhs.has(func)
+ if solve_for_func and not solved:
+ solved = solve(sol, func)
+ if solved:
+ if len(solved) == 1:
+ return checkpdesol(pde, Eq(func, solved[0]),
+ func=func, solve_for_func=False)
+ else:
+ return checkpdesol(pde, [Eq(func, t) for t in solved],
+ func=func, solve_for_func=False)
+
+ # try direct substitution of the solution into the PDE and simplify
+ if sol.lhs == func:
+ pde = pde.lhs - pde.rhs
+ s = simplify(pde.subs(func, sol.rhs).doit())
+ return s is S.Zero, s
+
+ raise NotImplementedError(filldedent('''
+ Unable to test if %s is a solution to %s.''' % (sol, pde)))
+
+
+
+def pde_1st_linear_constant_coeff_homogeneous(eq, func, order, match, solvefun):
+ r"""
+ Solves a first order linear homogeneous
+ partial differential equation with constant coefficients.
+
+ The general form of this partial differential equation is
+
+ .. math:: a \frac{\partial f(x,y)}{\partial x}
+ + b \frac{\partial f(x,y)}{\partial y} + c f(x,y) = 0
+
+ where `a`, `b` and `c` are constants.
+
+ The general solution is of the form:
+
+ .. math::
+ f(x, y) = F(- a y + b x ) e^{- \frac{c (a x + b y)}{a^2 + b^2}}
+
+ and can be found in SymPy with ``pdsolve``::
+
+ >>> from sympy.solvers import pdsolve
+ >>> from sympy.abc import x, y, a, b, c
+ >>> from sympy import Function, pprint
+ >>> f = Function('f')
+ >>> u = f(x,y)
+ >>> ux = u.diff(x)
+ >>> uy = u.diff(y)
+ >>> genform = a*ux + b*uy + c*u
+ >>> pprint(genform)
+ d d
+ a*--(f(x, y)) + b*--(f(x, y)) + c*f(x, y)
+ dx dy
+
+ >>> pprint(pdsolve(genform))
+ -c*(a*x + b*y)
+ ---------------
+ 2 2
+ a + b
+ f(x, y) = F(-a*y + b*x)*e
+
+ Examples
+ ========
+
+ >>> from sympy import pdsolve
+ >>> from sympy import Function, pprint
+ >>> from sympy.abc import x,y
+ >>> f = Function('f')
+ >>> pdsolve(f(x,y) + f(x,y).diff(x) + f(x,y).diff(y))
+ Eq(f(x, y), F(x - y)*exp(-x/2 - y/2))
+ >>> pprint(pdsolve(f(x,y) + f(x,y).diff(x) + f(x,y).diff(y)))
+ x y
+ - - - -
+ 2 2
+ f(x, y) = F(x - y)*e
+
+ References
+ ==========
+
+ - Viktor Grigoryan, "Partial Differential Equations"
+ Math 124A - Fall 2010, pp.7
+
+ """
+ # TODO : For now homogeneous first order linear PDE's having
+ # two variables are implemented. Once there is support for
+ # solving systems of ODE's, this can be extended to n variables.
+
+ f = func.func
+ x = func.args[0]
+ y = func.args[1]
+ b = match[match['b']]
+ c = match[match['c']]
+ d = match[match['d']]
+ return Eq(f(x,y), exp(-S(d)/(b**2 + c**2)*(b*x + c*y))*solvefun(c*x - b*y))
+
+
+def pde_1st_linear_constant_coeff(eq, func, order, match, solvefun):
+ r"""
+ Solves a first order linear partial differential equation
+ with constant coefficients.
+
+ The general form of this partial differential equation is
+
+ .. math:: a \frac{\partial f(x,y)}{\partial x}
+ + b \frac{\partial f(x,y)}{\partial y}
+ + c f(x,y) = G(x,y)
+
+ where `a`, `b` and `c` are constants and `G(x, y)` can be an arbitrary
+ function in `x` and `y`.
+
+ The general solution of the PDE is:
+
+ .. math::
+ f(x, y) = \left. \left[F(\eta) + \frac{1}{a^2 + b^2}
+ \int\limits^{a x + b y} G\left(\frac{a \xi + b \eta}{a^2 + b^2},
+ \frac{- a \eta + b \xi}{a^2 + b^2} \right)
+ e^{\frac{c \xi}{a^2 + b^2}}\, d\xi\right]
+ e^{- \frac{c \xi}{a^2 + b^2}}
+ \right|_{\substack{\eta=- a y + b x\\ \xi=a x + b y }}\, ,
+
+ where `F(\eta)` is an arbitrary single-valued function. The solution
+ can be found in SymPy with ``pdsolve``::
+
+ >>> from sympy.solvers import pdsolve
+ >>> from sympy.abc import x, y, a, b, c
+ >>> from sympy import Function, pprint
+ >>> f = Function('f')
+ >>> G = Function('G')
+ >>> u = f(x,y)
+ >>> ux = u.diff(x)
+ >>> uy = u.diff(y)
+ >>> genform = a*ux + b*uy + c*u - G(x,y)
+ >>> pprint(genform)
+ d d
+ a*--(f(x, y)) + b*--(f(x, y)) + c*f(x, y) - G(x, y)
+ dx dy
+ >>> pprint(pdsolve(genform, hint='1st_linear_constant_coeff_Integral'))
+ // a*x + b*y \
+ || / |
+ || | |
+ || | c*xi |
+ || | ------- |
+ || | 2 2 |
+ || | /a*xi + b*eta -a*eta + b*xi\ a + b |
+ || | G|------------, -------------|*e d(xi)|
+ || | | 2 2 2 2 | |
+ || | \ a + b a + b / |
+ || | |
+ || / |
+ || |
+ f(x, y) = ||F(eta) + -------------------------------------------------------|*
+ || 2 2 |
+ \\ a + b /
+
+ \|
+ ||
+ ||
+ ||
+ ||
+ ||
+ ||
+ ||
+ ||
+ -c*xi ||
+ -------||
+ 2 2||
+ a + b ||
+ e ||
+ ||
+ /|eta=-a*y + b*x, xi=a*x + b*y
+
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.pde import pdsolve
+ >>> from sympy import Function, pprint, exp
+ >>> from sympy.abc import x,y
+ >>> f = Function('f')
+ >>> eq = -2*f(x,y).diff(x) + 4*f(x,y).diff(y) + 5*f(x,y) - exp(x + 3*y)
+ >>> pdsolve(eq)
+ Eq(f(x, y), (F(4*x + 2*y)*exp(x/2) + exp(x + 4*y)/15)*exp(-y))
+
+ References
+ ==========
+
+ - Viktor Grigoryan, "Partial Differential Equations"
+ Math 124A - Fall 2010, pp.7
+
+ """
+
+ # TODO : For now homogeneous first order linear PDE's having
+ # two variables are implemented. Once there is support for
+ # solving systems of ODE's, this can be extended to n variables.
+ xi, eta = symbols("xi eta")
+ f = func.func
+ x = func.args[0]
+ y = func.args[1]
+ b = match[match['b']]
+ c = match[match['c']]
+ d = match[match['d']]
+ e = -match[match['e']]
+ expterm = exp(-S(d)/(b**2 + c**2)*xi)
+ functerm = solvefun(eta)
+ solvedict = solve((b*x + c*y - xi, c*x - b*y - eta), x, y)
+ # Integral should remain as it is in terms of xi,
+ # doit() should be done in _handle_Integral.
+ genterm = (1/S(b**2 + c**2))*Integral(
+ (1/expterm*e).subs(solvedict), (xi, b*x + c*y))
+ return Eq(f(x,y), Subs(expterm*(functerm + genterm),
+ (eta, xi), (c*x - b*y, b*x + c*y)))
+
+
+def pde_1st_linear_variable_coeff(eq, func, order, match, solvefun):
+ r"""
+ Solves a first order linear partial differential equation
+ with variable coefficients. The general form of this partial
+ differential equation is
+
+ .. math:: a(x, y) \frac{\partial f(x, y)}{\partial x}
+ + b(x, y) \frac{\partial f(x, y)}{\partial y}
+ + c(x, y) f(x, y) = G(x, y)
+
+ where `a(x, y)`, `b(x, y)`, `c(x, y)` and `G(x, y)` are arbitrary
+ functions in `x` and `y`. This PDE is converted into an ODE by
+ making the following transformation:
+
+ 1. `\xi` as `x`
+
+ 2. `\eta` as the constant in the solution to the differential
+ equation `\frac{dy}{dx} = -\frac{b}{a}`
+
+ Making the previous substitutions reduces it to the linear ODE
+
+ .. math:: a(\xi, \eta)\frac{du}{d\xi} + c(\xi, \eta)u - G(\xi, \eta) = 0
+
+ which can be solved using ``dsolve``.
+
+ >>> from sympy.abc import x, y
+ >>> from sympy import Function, pprint
+ >>> a, b, c, G, f= [Function(i) for i in ['a', 'b', 'c', 'G', 'f']]
+ >>> u = f(x,y)
+ >>> ux = u.diff(x)
+ >>> uy = u.diff(y)
+ >>> genform = a(x, y)*u + b(x, y)*ux + c(x, y)*uy - G(x,y)
+ >>> pprint(genform)
+ d d
+ -G(x, y) + a(x, y)*f(x, y) + b(x, y)*--(f(x, y)) + c(x, y)*--(f(x, y))
+ dx dy
+
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.pde import pdsolve
+ >>> from sympy import Function, pprint
+ >>> from sympy.abc import x,y
+ >>> f = Function('f')
+ >>> eq = x*(u.diff(x)) - y*(u.diff(y)) + y**2*u - y**2
+ >>> pdsolve(eq)
+ Eq(f(x, y), F(x*y)*exp(y**2/2) + 1)
+
+ References
+ ==========
+
+ - Viktor Grigoryan, "Partial Differential Equations"
+ Math 124A - Fall 2010, pp.7
+
+ """
+ from sympy.solvers.ode import dsolve
+
+ xi, eta = symbols("xi eta")
+ f = func.func
+ x = func.args[0]
+ y = func.args[1]
+ b = match[match['b']]
+ c = match[match['c']]
+ d = match[match['d']]
+ e = -match[match['e']]
+
+
+ if not d:
+ # To deal with cases like b*ux = e or c*uy = e
+ if not (b and c):
+ if c:
+ try:
+ tsol = integrate(e/c, y)
+ except NotImplementedError:
+ raise NotImplementedError("Unable to find a solution"
+ " due to inability of integrate")
+ else:
+ return Eq(f(x,y), solvefun(x) + tsol)
+ if b:
+ try:
+ tsol = integrate(e/b, x)
+ except NotImplementedError:
+ raise NotImplementedError("Unable to find a solution"
+ " due to inability of integrate")
+ else:
+ return Eq(f(x,y), solvefun(y) + tsol)
+
+ if not c:
+ # To deal with cases when c is 0, a simpler method is used.
+ # The PDE reduces to b*(u.diff(x)) + d*u = e, which is a linear ODE in x
+ plode = f(x).diff(x)*b + d*f(x) - e
+ sol = dsolve(plode, f(x))
+ syms = sol.free_symbols - plode.free_symbols - {x, y}
+ rhs = _simplify_variable_coeff(sol.rhs, syms, solvefun, y)
+ return Eq(f(x, y), rhs)
+
+ if not b:
+ # To deal with cases when b is 0, a simpler method is used.
+ # The PDE reduces to c*(u.diff(y)) + d*u = e, which is a linear ODE in y
+ plode = f(y).diff(y)*c + d*f(y) - e
+ sol = dsolve(plode, f(y))
+ syms = sol.free_symbols - plode.free_symbols - {x, y}
+ rhs = _simplify_variable_coeff(sol.rhs, syms, solvefun, x)
+ return Eq(f(x, y), rhs)
+
+ dummy = Function('d')
+ h = (c/b).subs(y, dummy(x))
+ sol = dsolve(dummy(x).diff(x) - h, dummy(x))
+ if isinstance(sol, list):
+ sol = sol[0]
+ solsym = sol.free_symbols - h.free_symbols - {x, y}
+ if len(solsym) == 1:
+ solsym = solsym.pop()
+ etat = (solve(sol, solsym)[0]).subs(dummy(x), y)
+ ysub = solve(eta - etat, y)[0]
+ deq = (b*(f(x).diff(x)) + d*f(x) - e).subs(y, ysub)
+ final = (dsolve(deq, f(x), hint='1st_linear')).rhs
+ if isinstance(final, list):
+ final = final[0]
+ finsyms = final.free_symbols - deq.free_symbols - {x, y}
+ rhs = _simplify_variable_coeff(final, finsyms, solvefun, etat)
+ return Eq(f(x, y), rhs)
+
+ else:
+ raise NotImplementedError("Cannot solve the partial differential equation due"
+ " to inability of constantsimp")
+
+
+def _simplify_variable_coeff(sol, syms, func, funcarg):
+ r"""
+ Helper function to replace constants by functions in 1st_linear_variable_coeff
+ """
+ eta = Symbol("eta")
+ if len(syms) == 1:
+ sym = syms.pop()
+ final = sol.subs(sym, func(funcarg))
+
+ else:
+ for key, sym in enumerate(syms):
+ final = sol.subs(sym, func(funcarg))
+
+ return simplify(final.subs(eta, funcarg))
+
+
+def pde_separate(eq, fun, sep, strategy='mul'):
+ """Separate variables in partial differential equation either by additive
+ or multiplicative separation approach. It tries to rewrite an equation so
+ that one of the specified variables occurs on a different side of the
+ equation than the others.
+
+ :param eq: Partial differential equation
+
+ :param fun: Original function F(x, y, z)
+
+ :param sep: List of separated functions [X(x), u(y, z)]
+
+ :param strategy: Separation strategy. You can choose between additive
+ separation ('add') and multiplicative separation ('mul') which is
+ default.
+
+ Examples
+ ========
+
+ >>> from sympy import E, Eq, Function, pde_separate, Derivative as D
+ >>> from sympy.abc import x, t
+ >>> u, X, T = map(Function, 'uXT')
+
+ >>> eq = Eq(D(u(x, t), x), E**(u(x, t))*D(u(x, t), t))
+ >>> pde_separate(eq, u(x, t), [X(x), T(t)], strategy='add')
+ [exp(-X(x))*Derivative(X(x), x), exp(T(t))*Derivative(T(t), t)]
+
+ >>> eq = Eq(D(u(x, t), x, 2), D(u(x, t), t, 2))
+ >>> pde_separate(eq, u(x, t), [X(x), T(t)], strategy='mul')
+ [Derivative(X(x), (x, 2))/X(x), Derivative(T(t), (t, 2))/T(t)]
+
+ See Also
+ ========
+ pde_separate_add, pde_separate_mul
+ """
+
+ do_add = False
+ if strategy == 'add':
+ do_add = True
+ elif strategy == 'mul':
+ do_add = False
+ else:
+ raise ValueError('Unknown strategy: %s' % strategy)
+
+ if isinstance(eq, Equality):
+ if eq.rhs != 0:
+ return pde_separate(Eq(eq.lhs - eq.rhs, 0), fun, sep, strategy)
+ else:
+ return pde_separate(Eq(eq, 0), fun, sep, strategy)
+
+ if eq.rhs != 0:
+ raise ValueError("Value should be 0")
+
+ # Handle arguments
+ orig_args = list(fun.args)
+ subs_args = [arg for s in sep for arg in s.args]
+
+ if do_add:
+ functions = reduce(operator.add, sep)
+ else:
+ functions = reduce(operator.mul, sep)
+
+ # Check whether variables match
+ if len(subs_args) != len(orig_args):
+ raise ValueError("Variable counts do not match")
+ # Check for duplicate arguments like [X(x), u(x, y)]
+ if has_dups(subs_args):
+ raise ValueError("Duplicate substitution arguments detected")
+ # Check whether the variables match
+ if set(orig_args) != set(subs_args):
+ raise ValueError("Arguments do not match")
+
+ # Substitute original function with separated...
+ result = eq.lhs.subs(fun, functions).doit()
+
+ # Divide by terms when doing multiplicative separation
+ if not do_add:
+ eq = 0
+ for i in result.args:
+ eq += i/functions
+ result = eq
+
+ svar = subs_args[0]
+ dvar = subs_args[1:]
+ return _separate(result, svar, dvar)
+
+
+def pde_separate_add(eq, fun, sep):
+ """
+ Helper function for searching additive separable solutions.
+
+ Consider an equation of two independent variables x, y and a dependent
+ variable w, we look for the product of two functions depending on different
+ arguments:
+
+ `w(x, y, z) = X(x) + y(y, z)`
+
+ Examples
+ ========
+
+ >>> from sympy import E, Eq, Function, pde_separate_add, Derivative as D
+ >>> from sympy.abc import x, t
+ >>> u, X, T = map(Function, 'uXT')
+
+ >>> eq = Eq(D(u(x, t), x), E**(u(x, t))*D(u(x, t), t))
+ >>> pde_separate_add(eq, u(x, t), [X(x), T(t)])
+ [exp(-X(x))*Derivative(X(x), x), exp(T(t))*Derivative(T(t), t)]
+
+ """
+ return pde_separate(eq, fun, sep, strategy='add')
+
+
+def pde_separate_mul(eq, fun, sep):
+ """
+ Helper function for searching multiplicative separable solutions.
+
+ Consider an equation of two independent variables x, y and a dependent
+ variable w, we look for the product of two functions depending on different
+ arguments:
+
+ `w(x, y, z) = X(x)*u(y, z)`
+
+ Examples
+ ========
+
+ >>> from sympy import Function, Eq, pde_separate_mul, Derivative as D
+ >>> from sympy.abc import x, y
+ >>> u, X, Y = map(Function, 'uXY')
+
+ >>> eq = Eq(D(u(x, y), x, 2), D(u(x, y), y, 2))
+ >>> pde_separate_mul(eq, u(x, y), [X(x), Y(y)])
+ [Derivative(X(x), (x, 2))/X(x), Derivative(Y(y), (y, 2))/Y(y)]
+
+ """
+ return pde_separate(eq, fun, sep, strategy='mul')
+
+
+def _separate(eq, dep, others):
+ """Separate expression into two parts based on dependencies of variables."""
+
+ # FIRST PASS
+ # Extract derivatives depending our separable variable...
+ terms = set()
+ for term in eq.args:
+ if term.is_Mul:
+ for i in term.args:
+ if i.is_Derivative and not i.has(*others):
+ terms.add(term)
+ continue
+ elif term.is_Derivative and not term.has(*others):
+ terms.add(term)
+ # Find the factor that we need to divide by
+ div = set()
+ for term in terms:
+ ext, sep = term.expand().as_independent(dep)
+ # Failed?
+ if sep.has(*others):
+ return None
+ div.add(ext)
+ # FIXME: Find lcm() of all the divisors and divide with it, instead of
+ # current hack :(
+ # https://github.com/sympy/sympy/issues/4597
+ if len(div) > 0:
+ # double sum required or some tests will fail
+ eq = Add(*[simplify(Add(*[term/i for i in div])) for term in eq.args])
+ # SECOND PASS - separate the derivatives
+ div = set()
+ lhs = rhs = 0
+ for term in eq.args:
+ # Check, whether we have already term with independent variable...
+ if not term.has(*others):
+ lhs += term
+ continue
+ # ...otherwise, try to separate
+ temp, sep = term.expand().as_independent(dep)
+ # Failed?
+ if sep.has(*others):
+ return None
+ # Extract the divisors
+ div.add(sep)
+ rhs -= term.expand()
+ # Do the division
+ fulldiv = reduce(operator.add, div)
+ lhs = simplify(lhs/fulldiv).expand()
+ rhs = simplify(rhs/fulldiv).expand()
+ # ...and check whether we were successful :)
+ if lhs.has(*others) or rhs.has(dep):
+ return None
+ return [lhs, rhs]
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/polysys.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/polysys.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef88f2fa82c9472c444e4ad2aed3903501f82b0a
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/polysys.py
@@ -0,0 +1,440 @@
+"""Solvers of systems of polynomial equations. """
+import itertools
+
+from sympy.core import S
+from sympy.core.sorting import default_sort_key
+from sympy.polys import Poly, groebner, roots
+from sympy.polys.polytools import parallel_poly_from_expr
+from sympy.polys.polyerrors import (ComputationFailed,
+ PolificationFailed, CoercionFailed)
+from sympy.simplify import rcollect
+from sympy.utilities import postfixes
+from sympy.utilities.misc import filldedent
+
+
+class SolveFailed(Exception):
+ """Raised when solver's conditions were not met. """
+
+
+def solve_poly_system(seq, *gens, strict=False, **args):
+ """
+ Return a list of solutions for the system of polynomial equations
+ or else None.
+
+ Parameters
+ ==========
+
+ seq: a list/tuple/set
+ Listing all the equations that are needed to be solved
+ gens: generators
+ generators of the equations in seq for which we want the
+ solutions
+ strict: a boolean (default is False)
+ if strict is True, NotImplementedError will be raised if
+ the solution is known to be incomplete (which can occur if
+ not all solutions are expressible in radicals)
+ args: Keyword arguments
+ Special options for solving the equations.
+
+
+ Returns
+ =======
+
+ List[Tuple]
+ a list of tuples with elements being solutions for the
+ symbols in the order they were passed as gens
+ None
+ None is returned when the computed basis contains only the ground.
+
+ Examples
+ ========
+
+ >>> from sympy import solve_poly_system
+ >>> from sympy.abc import x, y
+
+ >>> solve_poly_system([x*y - 2*y, 2*y**2 - x**2], x, y)
+ [(0, 0), (2, -sqrt(2)), (2, sqrt(2))]
+
+ >>> solve_poly_system([x**5 - x + y**3, y**2 - 1], x, y, strict=True)
+ Traceback (most recent call last):
+ ...
+ UnsolvableFactorError
+
+ """
+ try:
+ polys, opt = parallel_poly_from_expr(seq, *gens, **args)
+ except PolificationFailed as exc:
+ raise ComputationFailed('solve_poly_system', len(seq), exc)
+
+ if len(polys) == len(opt.gens) == 2:
+ f, g = polys
+
+ if all(i <= 2 for i in f.degree_list() + g.degree_list()):
+ try:
+ return solve_biquadratic(f, g, opt)
+ except SolveFailed:
+ pass
+
+ return solve_generic(polys, opt, strict=strict)
+
+
+def solve_biquadratic(f, g, opt):
+ """Solve a system of two bivariate quadratic polynomial equations.
+
+ Parameters
+ ==========
+
+ f: a single Expr or Poly
+ First equation
+ g: a single Expr or Poly
+ Second Equation
+ opt: an Options object
+ For specifying keyword arguments and generators
+
+ Returns
+ =======
+
+ List[Tuple]
+ a list of tuples with elements being solutions for the
+ symbols in the order they were passed as gens
+ None
+ None is returned when the computed basis contains only the ground.
+
+ Examples
+ ========
+
+ >>> from sympy import Options, Poly
+ >>> from sympy.abc import x, y
+ >>> from sympy.solvers.polysys import solve_biquadratic
+ >>> NewOption = Options((x, y), {'domain': 'ZZ'})
+
+ >>> a = Poly(y**2 - 4 + x, y, x, domain='ZZ')
+ >>> b = Poly(y*2 + 3*x - 7, y, x, domain='ZZ')
+ >>> solve_biquadratic(a, b, NewOption)
+ [(1/3, 3), (41/27, 11/9)]
+
+ >>> a = Poly(y + x**2 - 3, y, x, domain='ZZ')
+ >>> b = Poly(-y + x - 4, y, x, domain='ZZ')
+ >>> solve_biquadratic(a, b, NewOption)
+ [(7/2 - sqrt(29)/2, -sqrt(29)/2 - 1/2), (sqrt(29)/2 + 7/2, -1/2 + \
+ sqrt(29)/2)]
+ """
+ G = groebner([f, g])
+
+ if len(G) == 1 and G[0].is_ground:
+ return None
+
+ if len(G) != 2:
+ raise SolveFailed
+
+ x, y = opt.gens
+ p, q = G
+ if not p.gcd(q).is_ground:
+ # not 0-dimensional
+ raise SolveFailed
+
+ p = Poly(p, x, expand=False)
+ p_roots = [rcollect(expr, y) for expr in roots(p).keys()]
+
+ q = q.ltrim(-1)
+ q_roots = list(roots(q).keys())
+
+ solutions = [(p_root.subs(y, q_root), q_root) for q_root, p_root in
+ itertools.product(q_roots, p_roots)]
+
+ return sorted(solutions, key=default_sort_key)
+
+
+def solve_generic(polys, opt, strict=False):
+ """
+ Solve a generic system of polynomial equations.
+
+ Returns all possible solutions over C[x_1, x_2, ..., x_m] of a
+ set F = { f_1, f_2, ..., f_n } of polynomial equations, using
+ Groebner basis approach. For now only zero-dimensional systems
+ are supported, which means F can have at most a finite number
+ of solutions. If the basis contains only the ground, None is
+ returned.
+
+ The algorithm works by the fact that, supposing G is the basis
+ of F with respect to an elimination order (here lexicographic
+ order is used), G and F generate the same ideal, they have the
+ same set of solutions. By the elimination property, if G is a
+ reduced, zero-dimensional Groebner basis, then there exists an
+ univariate polynomial in G (in its last variable). This can be
+ solved by computing its roots. Substituting all computed roots
+ for the last (eliminated) variable in other elements of G, new
+ polynomial system is generated. Applying the above procedure
+ recursively, a finite number of solutions can be found.
+
+ The ability of finding all solutions by this procedure depends
+ on the root finding algorithms. If no solutions were found, it
+ means only that roots() failed, but the system is solvable. To
+ overcome this difficulty use numerical algorithms instead.
+
+ Parameters
+ ==========
+
+ polys: a list/tuple/set
+ Listing all the polynomial equations that are needed to be solved
+ opt: an Options object
+ For specifying keyword arguments and generators
+ strict: a boolean
+ If strict is True, NotImplementedError will be raised if the solution
+ is known to be incomplete
+
+ Returns
+ =======
+
+ List[Tuple]
+ a list of tuples with elements being solutions for the
+ symbols in the order they were passed as gens
+ None
+ None is returned when the computed basis contains only the ground.
+
+ References
+ ==========
+
+ .. [Buchberger01] B. Buchberger, Groebner Bases: A Short
+ Introduction for Systems Theorists, In: R. Moreno-Diaz,
+ B. Buchberger, J.L. Freire, Proceedings of EUROCAST'01,
+ February, 2001
+
+ .. [Cox97] D. Cox, J. Little, D. O'Shea, Ideals, Varieties
+ and Algorithms, Springer, Second Edition, 1997, pp. 112
+
+ Raises
+ ========
+
+ NotImplementedError
+ If the system is not zero-dimensional (does not have a finite
+ number of solutions)
+
+ UnsolvableFactorError
+ If ``strict`` is True and not all solution components are
+ expressible in radicals
+
+ Examples
+ ========
+
+ >>> from sympy import Poly, Options
+ >>> from sympy.solvers.polysys import solve_generic
+ >>> from sympy.abc import x, y
+ >>> NewOption = Options((x, y), {'domain': 'ZZ'})
+
+ >>> a = Poly(x - y + 5, x, y, domain='ZZ')
+ >>> b = Poly(x + y - 3, x, y, domain='ZZ')
+ >>> solve_generic([a, b], NewOption)
+ [(-1, 4)]
+
+ >>> a = Poly(x - 2*y + 5, x, y, domain='ZZ')
+ >>> b = Poly(2*x - y - 3, x, y, domain='ZZ')
+ >>> solve_generic([a, b], NewOption)
+ [(11/3, 13/3)]
+
+ >>> a = Poly(x**2 + y, x, y, domain='ZZ')
+ >>> b = Poly(x + y*4, x, y, domain='ZZ')
+ >>> solve_generic([a, b], NewOption)
+ [(0, 0), (1/4, -1/16)]
+
+ >>> a = Poly(x**5 - x + y**3, x, y, domain='ZZ')
+ >>> b = Poly(y**2 - 1, x, y, domain='ZZ')
+ >>> solve_generic([a, b], NewOption, strict=True)
+ Traceback (most recent call last):
+ ...
+ UnsolvableFactorError
+
+ """
+ def _is_univariate(f):
+ """Returns True if 'f' is univariate in its last variable. """
+ for monom in f.monoms():
+ if any(monom[:-1]):
+ return False
+
+ return True
+
+ def _subs_root(f, gen, zero):
+ """Replace generator with a root so that the result is nice. """
+ p = f.as_expr({gen: zero})
+
+ if f.degree(gen) >= 2:
+ p = p.expand(deep=False)
+
+ return p
+
+ def _solve_reduced_system(system, gens, entry=False):
+ """Recursively solves reduced polynomial systems. """
+ if len(system) == len(gens) == 1:
+ # the below line will produce UnsolvableFactorError if
+ # strict=True and the solution from `roots` is incomplete
+ zeros = list(roots(system[0], gens[-1], strict=strict).keys())
+ return [(zero,) for zero in zeros]
+
+ basis = groebner(system, gens, polys=True)
+
+ if len(basis) == 1 and basis[0].is_ground:
+ if not entry:
+ return []
+ else:
+ return None
+
+ univariate = list(filter(_is_univariate, basis))
+
+ if len(basis) < len(gens):
+ raise NotImplementedError(filldedent('''
+ only zero-dimensional systems supported
+ (finite number of solutions)
+ '''))
+
+ if len(univariate) == 1:
+ f = univariate.pop()
+ else:
+ raise NotImplementedError(filldedent('''
+ only zero-dimensional systems supported
+ (finite number of solutions)
+ '''))
+
+ gens = f.gens
+ gen = gens[-1]
+
+ # the below line will produce UnsolvableFactorError if
+ # strict=True and the solution from `roots` is incomplete
+ zeros = list(roots(f.ltrim(gen), strict=strict).keys())
+
+ if not zeros:
+ return []
+
+ if len(basis) == 1:
+ return [(zero,) for zero in zeros]
+
+ solutions = []
+
+ for zero in zeros:
+ new_system = []
+ new_gens = gens[:-1]
+
+ for b in basis[:-1]:
+ eq = _subs_root(b, gen, zero)
+
+ if eq is not S.Zero:
+ new_system.append(eq)
+
+ for solution in _solve_reduced_system(new_system, new_gens):
+ solutions.append(solution + (zero,))
+
+ if solutions and len(solutions[0]) != len(gens):
+ raise NotImplementedError(filldedent('''
+ only zero-dimensional systems supported
+ (finite number of solutions)
+ '''))
+ return solutions
+
+ try:
+ result = _solve_reduced_system(polys, opt.gens, entry=True)
+ except CoercionFailed:
+ raise NotImplementedError
+
+ if result is not None:
+ return sorted(result, key=default_sort_key)
+
+
+def solve_triangulated(polys, *gens, **args):
+ """
+ Solve a polynomial system using Gianni-Kalkbrenner algorithm.
+
+ The algorithm proceeds by computing one Groebner basis in the ground
+ domain and then by iteratively computing polynomial factorizations in
+ appropriately constructed algebraic extensions of the ground domain.
+
+ Parameters
+ ==========
+
+ polys: a list/tuple/set
+ Listing all the equations that are needed to be solved
+ gens: generators
+ generators of the equations in polys for which we want the
+ solutions
+ args: Keyword arguments
+ Special options for solving the equations
+
+ Returns
+ =======
+
+ List[Tuple]
+ A List of tuples. Solutions for symbols that satisfy the
+ equations listed in polys
+
+ Examples
+ ========
+
+ >>> from sympy import solve_triangulated
+ >>> from sympy.abc import x, y, z
+
+ >>> F = [x**2 + y + z - 1, x + y**2 + z - 1, x + y + z**2 - 1]
+
+ >>> solve_triangulated(F, x, y, z)
+ [(0, 0, 1), (0, 1, 0), (1, 0, 0)]
+
+ References
+ ==========
+
+ 1. Patrizia Gianni, Teo Mora, Algebraic Solution of System of
+ Polynomial Equations using Groebner Bases, AAECC-5 on Applied Algebra,
+ Algebraic Algorithms and Error-Correcting Codes, LNCS 356 247--257, 1989
+
+ """
+ G = groebner(polys, gens, polys=True)
+ G = list(reversed(G))
+
+ domain = args.get('domain')
+
+ if domain is not None:
+ for i, g in enumerate(G):
+ G[i] = g.set_domain(domain)
+
+ f, G = G[0].ltrim(-1), G[1:]
+ dom = f.get_domain()
+
+ zeros = f.ground_roots()
+ solutions = set()
+
+ for zero in zeros:
+ solutions.add(((zero,), dom))
+
+ var_seq = reversed(gens[:-1])
+ vars_seq = postfixes(gens[1:])
+
+ for var, vars in zip(var_seq, vars_seq):
+ _solutions = set()
+
+ for values, dom in solutions:
+ H, mapping = [], list(zip(vars, values))
+
+ for g in G:
+ _vars = (var,) + vars
+
+ if g.has_only_gens(*_vars) and g.degree(var) != 0:
+ h = g.ltrim(var).eval(dict(mapping))
+
+ if g.degree(var) == h.degree():
+ H.append(h)
+
+ p = min(H, key=lambda h: h.degree())
+ zeros = p.ground_roots()
+
+ for zero in zeros:
+ if not zero.is_Rational:
+ dom_zero = dom.algebraic_field(zero)
+ else:
+ dom_zero = dom
+
+ _solutions.add(((zero,) + values, dom_zero))
+
+ solutions = _solutions
+
+ solutions = list(solutions)
+
+ for i, (solution, _) in enumerate(solutions):
+ solutions[i] = solution
+
+ return sorted(solutions, key=default_sort_key)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/recurr.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/recurr.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba627bbd4cb0844f11a8743634f5f10328aadca8
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/recurr.py
@@ -0,0 +1,843 @@
+r"""
+This module is intended for solving recurrences or, in other words,
+difference equations. Currently supported are linear, inhomogeneous
+equations with polynomial or rational coefficients.
+
+The solutions are obtained among polynomials, rational functions,
+hypergeometric terms, or combinations of hypergeometric term which
+are pairwise dissimilar.
+
+``rsolve_X`` functions were meant as a low level interface
+for ``rsolve`` which would use Mathematica's syntax.
+
+Given a recurrence relation:
+
+ .. math:: a_{k}(n) y(n+k) + a_{k-1}(n) y(n+k-1) +
+ ... + a_{0}(n) y(n) = f(n)
+
+where `k > 0` and `a_{i}(n)` are polynomials in `n`. To use
+``rsolve_X`` we need to put all coefficients in to a list ``L`` of
+`k+1` elements the following way:
+
+ ``L = [a_{0}(n), ..., a_{k-1}(n), a_{k}(n)]``
+
+where ``L[i]``, for `i=0, \ldots, k`, maps to
+`a_{i}(n) y(n+i)` (`y(n+i)` is implicit).
+
+For example if we would like to compute `m`-th Bernoulli polynomial
+up to a constant (example was taken from rsolve_poly docstring),
+then we would use `b(n+1) - b(n) = m n^{m-1}` recurrence, which
+has solution `b(n) = B_m + C`.
+
+Then ``L = [-1, 1]`` and `f(n) = m n^(m-1)` and finally for `m=4`:
+
+>>> from sympy import Symbol, bernoulli, rsolve_poly
+>>> n = Symbol('n', integer=True)
+
+>>> rsolve_poly([-1, 1], 4*n**3, n)
+C0 + n**4 - 2*n**3 + n**2
+
+>>> bernoulli(4, n)
+n**4 - 2*n**3 + n**2 - 1/30
+
+For the sake of completeness, `f(n)` can be:
+
+ [1] a polynomial -> rsolve_poly
+ [2] a rational function -> rsolve_ratio
+ [3] a hypergeometric function -> rsolve_hyper
+"""
+from collections import defaultdict
+
+from sympy.concrete import product
+from sympy.core.singleton import S
+from sympy.core.numbers import Rational, I
+from sympy.core.symbol import Symbol, Wild, Dummy
+from sympy.core.relational import Equality
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.sorting import default_sort_key
+from sympy.core.sympify import sympify
+
+from sympy.simplify import simplify, hypersimp, hypersimilar # type: ignore
+from sympy.solvers import solve, solve_undetermined_coeffs
+from sympy.polys import Poly, quo, gcd, lcm, roots, resultant
+from sympy.functions import binomial, factorial, FallingFactorial, RisingFactorial
+from sympy.matrices import Matrix, casoratian
+from sympy.utilities.iterables import numbered_symbols
+
+
+def rsolve_poly(coeffs, f, n, shift=0, **hints):
+ r"""
+ Given linear recurrence operator `\operatorname{L}` of order
+ `k` with polynomial coefficients and inhomogeneous equation
+ `\operatorname{L} y = f`, where `f` is a polynomial, we seek for
+ all polynomial solutions over field `K` of characteristic zero.
+
+ The algorithm performs two basic steps:
+
+ (1) Compute degree `N` of the general polynomial solution.
+ (2) Find all polynomials of degree `N` or less
+ of `\operatorname{L} y = f`.
+
+ There are two methods for computing the polynomial solutions.
+ If the degree bound is relatively small, i.e. it's smaller than
+ or equal to the order of the recurrence, then naive method of
+ undetermined coefficients is being used. This gives a system
+ of algebraic equations with `N+1` unknowns.
+
+ In the other case, the algorithm performs transformation of the
+ initial equation to an equivalent one for which the system of
+ algebraic equations has only `r` indeterminates. This method is
+ quite sophisticated (in comparison with the naive one) and was
+ invented together by Abramov, Bronstein and Petkovsek.
+
+ It is possible to generalize the algorithm implemented here to
+ the case of linear q-difference and differential equations.
+
+ Lets say that we would like to compute `m`-th Bernoulli polynomial
+ up to a constant. For this we can use `b(n+1) - b(n) = m n^{m-1}`
+ recurrence, which has solution `b(n) = B_m + C`. For example:
+
+ >>> from sympy import Symbol, rsolve_poly
+ >>> n = Symbol('n', integer=True)
+
+ >>> rsolve_poly([-1, 1], 4*n**3, n)
+ C0 + n**4 - 2*n**3 + n**2
+
+ References
+ ==========
+
+ .. [1] S. A. Abramov, M. Bronstein and M. Petkovsek, On polynomial
+ solutions of linear operator equations, in: T. Levelt, ed.,
+ Proc. ISSAC '95, ACM Press, New York, 1995, 290-296.
+
+ .. [2] M. Petkovsek, Hypergeometric solutions of linear recurrences
+ with polynomial coefficients, J. Symbolic Computation,
+ 14 (1992), 243-264.
+
+ .. [3] M. Petkovsek, H. S. Wilf, D. Zeilberger, A = B, 1996.
+
+ """
+ f = sympify(f)
+
+ if not f.is_polynomial(n):
+ return None
+
+ homogeneous = f.is_zero
+
+ r = len(coeffs) - 1
+
+ coeffs = [Poly(coeff, n) for coeff in coeffs]
+
+ polys = [Poly(0, n)]*(r + 1)
+ terms = [(S.Zero, S.NegativeInfinity)]*(r + 1)
+
+ for i in range(r + 1):
+ for j in range(i, r + 1):
+ polys[i] += coeffs[j]*(binomial(j, i).as_poly(n))
+
+ if not polys[i].is_zero:
+ (exp,), coeff = polys[i].LT()
+ terms[i] = (coeff, exp)
+
+ d = b = terms[0][1]
+
+ for i in range(1, r + 1):
+ if terms[i][1] > d:
+ d = terms[i][1]
+
+ if terms[i][1] - i > b:
+ b = terms[i][1] - i
+
+ d, b = int(d), int(b)
+
+ x = Dummy('x')
+
+ degree_poly = S.Zero
+
+ for i in range(r + 1):
+ if terms[i][1] - i == b:
+ degree_poly += terms[i][0]*FallingFactorial(x, i)
+
+ nni_roots = list(roots(degree_poly, x, filter='Z',
+ predicate=lambda r: r >= 0).keys())
+
+ if nni_roots:
+ N = [max(nni_roots)]
+ else:
+ N = []
+
+ if homogeneous:
+ N += [-b - 1]
+ else:
+ N += [f.as_poly(n).degree() - b, -b - 1]
+
+ N = int(max(N))
+
+ if N < 0:
+ if homogeneous:
+ if hints.get('symbols', False):
+ return (S.Zero, [])
+ else:
+ return S.Zero
+ else:
+ return None
+
+ if N <= r:
+ C = []
+ y = E = S.Zero
+
+ for i in range(N + 1):
+ C.append(Symbol('C' + str(i + shift)))
+ y += C[i] * n**i
+
+ for i in range(r + 1):
+ E += coeffs[i].as_expr()*y.subs(n, n + i)
+
+ solutions = solve_undetermined_coeffs(E - f, C, n)
+
+ if solutions is not None:
+ _C = C
+ C = [c for c in C if (c not in solutions)]
+ result = y.subs(solutions)
+ else:
+ return None # TBD
+ else:
+ A = r
+ U = N + A + b + 1
+
+ nni_roots = list(roots(polys[r], filter='Z',
+ predicate=lambda r: r >= 0).keys())
+
+ if nni_roots != []:
+ a = max(nni_roots) + 1
+ else:
+ a = S.Zero
+
+ def _zero_vector(k):
+ return [S.Zero] * k
+
+ def _one_vector(k):
+ return [S.One] * k
+
+ def _delta(p, k):
+ B = S.One
+ D = p.subs(n, a + k)
+
+ for i in range(1, k + 1):
+ B *= Rational(i - k - 1, i)
+ D += B * p.subs(n, a + k - i)
+
+ return D
+
+ alpha = {}
+
+ for i in range(-A, d + 1):
+ I = _one_vector(d + 1)
+
+ for k in range(1, d + 1):
+ I[k] = I[k - 1] * (x + i - k + 1)/k
+
+ alpha[i] = S.Zero
+
+ for j in range(A + 1):
+ for k in range(d + 1):
+ B = binomial(k, i + j)
+ D = _delta(polys[j].as_expr(), k)
+
+ alpha[i] += I[k]*B*D
+
+ V = Matrix(U, A, lambda i, j: int(i == j))
+
+ if homogeneous:
+ for i in range(A, U):
+ v = _zero_vector(A)
+
+ for k in range(1, A + b + 1):
+ if i - k < 0:
+ break
+
+ B = alpha[k - A].subs(x, i - k)
+
+ for j in range(A):
+ v[j] += B * V[i - k, j]
+
+ denom = alpha[-A].subs(x, i)
+
+ for j in range(A):
+ V[i, j] = -v[j] / denom
+ else:
+ G = _zero_vector(U)
+
+ for i in range(A, U):
+ v = _zero_vector(A)
+ g = S.Zero
+
+ for k in range(1, A + b + 1):
+ if i - k < 0:
+ break
+
+ B = alpha[k - A].subs(x, i - k)
+
+ for j in range(A):
+ v[j] += B * V[i - k, j]
+
+ g += B * G[i - k]
+
+ denom = alpha[-A].subs(x, i)
+
+ for j in range(A):
+ V[i, j] = -v[j] / denom
+
+ G[i] = (_delta(f, i - A) - g) / denom
+
+ P, Q = _one_vector(U), _zero_vector(A)
+
+ for i in range(1, U):
+ P[i] = (P[i - 1] * (n - a - i + 1)/i).expand()
+
+ for i in range(A):
+ Q[i] = Add(*[(v*p).expand() for v, p in zip(V[:, i], P)])
+
+ if not homogeneous:
+ h = Add(*[(g*p).expand() for g, p in zip(G, P)])
+
+ C = [Symbol('C' + str(i + shift)) for i in range(A)]
+
+ g = lambda i: Add(*[c*_delta(q, i) for c, q in zip(C, Q)])
+
+ if homogeneous:
+ E = [g(i) for i in range(N + 1, U)]
+ else:
+ E = [g(i) + _delta(h, i) for i in range(N + 1, U)]
+
+ if E != []:
+ solutions = solve(E, *C)
+
+ if not solutions:
+ if homogeneous:
+ if hints.get('symbols', False):
+ return (S.Zero, [])
+ else:
+ return S.Zero
+ else:
+ return None
+ else:
+ solutions = {}
+
+ if homogeneous:
+ result = S.Zero
+ else:
+ result = h
+
+ _C = C[:]
+ for c, q in list(zip(C, Q)):
+ if c in solutions:
+ s = solutions[c]*q
+ C.remove(c)
+ else:
+ s = c*q
+
+ result += s.expand()
+
+ if C != _C:
+ # renumber so they are contiguous
+ result = result.xreplace(dict(zip(C, _C)))
+ C = _C[:len(C)]
+
+ if hints.get('symbols', False):
+ return (result, C)
+ else:
+ return result
+
+
+def rsolve_ratio(coeffs, f, n, **hints):
+ r"""
+ Given linear recurrence operator `\operatorname{L}` of order `k`
+ with polynomial coefficients and inhomogeneous equation
+ `\operatorname{L} y = f`, where `f` is a polynomial, we seek
+ for all rational solutions over field `K` of characteristic zero.
+
+ This procedure accepts only polynomials, however if you are
+ interested in solving recurrence with rational coefficients
+ then use ``rsolve`` which will pre-process the given equation
+ and run this procedure with polynomial arguments.
+
+ The algorithm performs two basic steps:
+
+ (1) Compute polynomial `v(n)` which can be used as universal
+ denominator of any rational solution of equation
+ `\operatorname{L} y = f`.
+
+ (2) Construct new linear difference equation by substitution
+ `y(n) = u(n)/v(n)` and solve it for `u(n)` finding all its
+ polynomial solutions. Return ``None`` if none were found.
+
+ The algorithm implemented here is a revised version of the original
+ Abramov's algorithm, developed in 1989. The new approach is much
+ simpler to implement and has better overall efficiency. This
+ method can be easily adapted to the q-difference equations case.
+
+ Besides finding rational solutions alone, this functions is
+ an important part of Hyper algorithm where it is used to find
+ a particular solution for the inhomogeneous part of a recurrence.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import x
+ >>> from sympy.solvers.recurr import rsolve_ratio
+ >>> rsolve_ratio([-2*x**3 + x**2 + 2*x - 1, 2*x**3 + x**2 - 6*x,
+ ... - 2*x**3 - 11*x**2 - 18*x - 9, 2*x**3 + 13*x**2 + 22*x + 8], 0, x)
+ C0*(2*x - 3)/(2*(x**2 - 1))
+
+ References
+ ==========
+
+ .. [1] S. A. Abramov, Rational solutions of linear difference
+ and q-difference equations with polynomial coefficients,
+ in: T. Levelt, ed., Proc. ISSAC '95, ACM Press, New York,
+ 1995, 285-289
+
+ See Also
+ ========
+
+ rsolve_hyper
+ """
+ f = sympify(f)
+
+ if not f.is_polynomial(n):
+ return None
+
+ coeffs = list(map(sympify, coeffs))
+
+ r = len(coeffs) - 1
+
+ A, B = coeffs[r], coeffs[0]
+ A = A.subs(n, n - r).expand()
+
+ h = Dummy('h')
+
+ res = resultant(A, B.subs(n, n + h), n)
+
+ if not res.is_polynomial(h):
+ p, q = res.as_numer_denom()
+ res = quo(p, q, h)
+
+ nni_roots = list(roots(res, h, filter='Z',
+ predicate=lambda r: r >= 0).keys())
+
+ if not nni_roots:
+ return rsolve_poly(coeffs, f, n, **hints)
+ else:
+ C, numers = S.One, [S.Zero]*(r + 1)
+
+ for i in range(int(max(nni_roots)), -1, -1):
+ d = gcd(A, B.subs(n, n + i), n)
+
+ A = quo(A, d, n)
+ B = quo(B, d.subs(n, n - i), n)
+
+ C *= Mul(*[d.subs(n, n - j) for j in range(i + 1)])
+
+ denoms = [C.subs(n, n + i) for i in range(r + 1)]
+
+ for i in range(r + 1):
+ g = gcd(coeffs[i], denoms[i], n)
+
+ numers[i] = quo(coeffs[i], g, n)
+ denoms[i] = quo(denoms[i], g, n)
+
+ for i in range(r + 1):
+ numers[i] *= Mul(*(denoms[:i] + denoms[i + 1:]))
+
+ result = rsolve_poly(numers, f * Mul(*denoms), n, **hints)
+
+ if result is not None:
+ if hints.get('symbols', False):
+ return (simplify(result[0] / C), result[1])
+ else:
+ return simplify(result / C)
+ else:
+ return None
+
+
+def rsolve_hyper(coeffs, f, n, **hints):
+ r"""
+ Given linear recurrence operator `\operatorname{L}` of order `k`
+ with polynomial coefficients and inhomogeneous equation
+ `\operatorname{L} y = f` we seek for all hypergeometric solutions
+ over field `K` of characteristic zero.
+
+ The inhomogeneous part can be either hypergeometric or a sum
+ of a fixed number of pairwise dissimilar hypergeometric terms.
+
+ The algorithm performs three basic steps:
+
+ (1) Group together similar hypergeometric terms in the
+ inhomogeneous part of `\operatorname{L} y = f`, and find
+ particular solution using Abramov's algorithm.
+
+ (2) Compute generating set of `\operatorname{L}` and find basis
+ in it, so that all solutions are linearly independent.
+
+ (3) Form final solution with the number of arbitrary
+ constants equal to dimension of basis of `\operatorname{L}`.
+
+ Term `a(n)` is hypergeometric if it is annihilated by first order
+ linear difference equations with polynomial coefficients or, in
+ simpler words, if consecutive term ratio is a rational function.
+
+ The output of this procedure is a linear combination of fixed
+ number of hypergeometric terms. However the underlying method
+ can generate larger class of solutions - D'Alembertian terms.
+
+ Note also that this method not only computes the kernel of the
+ inhomogeneous equation, but also reduces in to a basis so that
+ solutions generated by this procedure are linearly independent
+
+ Examples
+ ========
+
+ >>> from sympy.solvers import rsolve_hyper
+ >>> from sympy.abc import x
+
+ >>> rsolve_hyper([-1, -1, 1], 0, x)
+ C0*(1/2 - sqrt(5)/2)**x + C1*(1/2 + sqrt(5)/2)**x
+
+ >>> rsolve_hyper([-1, 1], 1 + x, x)
+ C0 + x*(x + 1)/2
+
+ References
+ ==========
+
+ .. [1] M. Petkovsek, Hypergeometric solutions of linear recurrences
+ with polynomial coefficients, J. Symbolic Computation,
+ 14 (1992), 243-264.
+
+ .. [2] M. Petkovsek, H. S. Wilf, D. Zeilberger, A = B, 1996.
+ """
+ coeffs = list(map(sympify, coeffs))
+
+ f = sympify(f)
+
+ r, kernel, symbols = len(coeffs) - 1, [], set()
+
+ if not f.is_zero:
+ if f.is_Add:
+ similar = {}
+
+ for g in f.expand().args:
+ if not g.is_hypergeometric(n):
+ return None
+
+ for h in similar.keys():
+ if hypersimilar(g, h, n):
+ similar[h] += g
+ break
+ else:
+ similar[g] = S.Zero
+
+ inhomogeneous = [g + h for g, h in similar.items()]
+ elif f.is_hypergeometric(n):
+ inhomogeneous = [f]
+ else:
+ return None
+
+ for i, g in enumerate(inhomogeneous):
+ coeff, polys = S.One, coeffs[:]
+ denoms = [S.One]*(r + 1)
+
+ s = hypersimp(g, n)
+
+ for j in range(1, r + 1):
+ coeff *= s.subs(n, n + j - 1)
+
+ p, q = coeff.as_numer_denom()
+
+ polys[j] *= p
+ denoms[j] = q
+
+ for j in range(r + 1):
+ polys[j] *= Mul(*(denoms[:j] + denoms[j + 1:]))
+
+ # FIXME: The call to rsolve_ratio below should suffice (rsolve_poly
+ # call can be removed) but the XFAIL test_rsolve_ratio_missed must
+ # be fixed first.
+ R = rsolve_ratio(polys, Mul(*denoms), n, symbols=True)
+ if R is not None:
+ R, syms = R
+ if syms:
+ R = R.subs(zip(syms, [0]*len(syms)))
+ else:
+ R = rsolve_poly(polys, Mul(*denoms), n)
+
+ if R:
+ inhomogeneous[i] *= R
+ else:
+ return None
+
+ result = Add(*inhomogeneous)
+ result = simplify(result)
+ else:
+ result = S.Zero
+
+ Z = Dummy('Z')
+
+ p, q = coeffs[0], coeffs[r].subs(n, n - r + 1)
+
+ p_factors = list(roots(p, n).keys())
+ q_factors = list(roots(q, n).keys())
+
+ factors = [(S.One, S.One)]
+
+ for p in p_factors:
+ for q in q_factors:
+ if p.is_integer and q.is_integer and p <= q:
+ continue
+ else:
+ factors += [(n - p, n - q)]
+
+ p = [(n - p, S.One) for p in p_factors]
+ q = [(S.One, n - q) for q in q_factors]
+
+ factors = p + factors + q
+
+ for A, B in factors:
+ polys, degrees = [], []
+ D = A*B.subs(n, n + r - 1)
+
+ for i in range(r + 1):
+ a = Mul(*[A.subs(n, n + j) for j in range(i)])
+ b = Mul(*[B.subs(n, n + j) for j in range(i, r)])
+
+ poly = quo(coeffs[i]*a*b, D, n)
+ polys.append(poly.as_poly(n))
+
+ if not poly.is_zero:
+ degrees.append(polys[i].degree())
+
+ if degrees:
+ d, poly = max(degrees), S.Zero
+ else:
+ return None
+
+ for i in range(r + 1):
+ coeff = polys[i].nth(d)
+
+ if coeff is not S.Zero:
+ poly += coeff * Z**i
+
+ for z in roots(poly, Z).keys():
+ if z.is_zero:
+ continue
+
+ recurr_coeffs = [polys[i].as_expr()*z**i for i in range(r + 1)]
+ if d == 0 and 0 != Add(*[recurr_coeffs[j]*j for j in range(1, r + 1)]):
+ # faster inline check (than calling rsolve_poly) for a
+ # constant solution to a constant coefficient recurrence.
+ sol = [Symbol("C" + str(len(symbols)))]
+ else:
+ sol, syms = rsolve_poly(recurr_coeffs, 0, n, len(symbols), symbols=True)
+ sol = sol.collect(syms)
+ sol = [sol.coeff(s) for s in syms]
+
+ for C in sol:
+ ratio = z * A * C.subs(n, n + 1) / B / C
+ ratio = simplify(ratio)
+ # If there is a nonnegative root in the denominator of the ratio,
+ # this indicates that the term y(n_root) is zero, and one should
+ # start the product with the term y(n_root + 1).
+ n0 = 0
+ for n_root in roots(ratio.as_numer_denom()[1], n).keys():
+ if n_root.has(I):
+ return None
+ elif (n0 < (n_root + 1)) == True:
+ n0 = n_root + 1
+ K = product(ratio, (n, n0, n - 1))
+ if K.has(factorial, FallingFactorial, RisingFactorial):
+ K = simplify(K)
+
+ if casoratian(kernel + [K], n, zero=False) != 0:
+ kernel.append(K)
+
+ kernel.sort(key=default_sort_key)
+ sk = list(zip(numbered_symbols('C'), kernel))
+
+ for C, ker in sk:
+ result += C * ker
+
+ if hints.get('symbols', False):
+ # XXX: This returns the symbols in a non-deterministic order
+ symbols |= {s for s, k in sk}
+ return (result, list(symbols))
+ else:
+ return result
+
+
+def rsolve(f, y, init=None):
+ r"""
+ Solve univariate recurrence with rational coefficients.
+
+ Given `k`-th order linear recurrence `\operatorname{L} y = f`,
+ or equivalently:
+
+ .. math:: a_{k}(n) y(n+k) + a_{k-1}(n) y(n+k-1) +
+ \cdots + a_{0}(n) y(n) = f(n)
+
+ where `a_{i}(n)`, for `i=0, \ldots, k`, are polynomials or rational
+ functions in `n`, and `f` is a hypergeometric function or a sum
+ of a fixed number of pairwise dissimilar hypergeometric terms in
+ `n`, finds all solutions or returns ``None``, if none were found.
+
+ Initial conditions can be given as a dictionary in two forms:
+
+ (1) ``{ n_0 : v_0, n_1 : v_1, ..., n_m : v_m}``
+ (2) ``{y(n_0) : v_0, y(n_1) : v_1, ..., y(n_m) : v_m}``
+
+ or as a list ``L`` of values:
+
+ ``L = [v_0, v_1, ..., v_m]``
+
+ where ``L[i] = v_i``, for `i=0, \ldots, m`, maps to `y(n_i)`.
+
+ Examples
+ ========
+
+ Lets consider the following recurrence:
+
+ .. math:: (n - 1) y(n + 2) - (n^2 + 3 n - 2) y(n + 1) +
+ 2 n (n + 1) y(n) = 0
+
+ >>> from sympy import Function, rsolve
+ >>> from sympy.abc import n
+ >>> y = Function('y')
+
+ >>> f = (n - 1)*y(n + 2) - (n**2 + 3*n - 2)*y(n + 1) + 2*n*(n + 1)*y(n)
+
+ >>> rsolve(f, y(n))
+ 2**n*C0 + C1*factorial(n)
+
+ >>> rsolve(f, y(n), {y(0):0, y(1):3})
+ 3*2**n - 3*factorial(n)
+
+ See Also
+ ========
+
+ rsolve_poly, rsolve_ratio, rsolve_hyper
+
+ """
+ if isinstance(f, Equality):
+ f = f.lhs - f.rhs
+
+ n = y.args[0]
+ k = Wild('k', exclude=(n,))
+
+ # Preprocess user input to allow things like
+ # y(n) + a*(y(n + 1) + y(n - 1))/2
+ f = f.expand().collect(y.func(Wild('m', integer=True)))
+
+ h_part = defaultdict(list)
+ i_part = []
+ for g in Add.make_args(f):
+ coeff, dep = g.as_coeff_mul(y.func)
+ if not dep:
+ i_part.append(coeff)
+ continue
+ for h in dep:
+ if h.is_Function and h.func == y.func:
+ result = h.args[0].match(n + k)
+ if result is not None:
+ h_part[int(result[k])].append(coeff)
+ continue
+ raise ValueError(
+ "'%s(%s + k)' expected, got '%s'" % (y.func, n, h))
+ for k in h_part:
+ h_part[k] = Add(*h_part[k])
+ h_part.default_factory = lambda: 0
+ i_part = Add(*i_part)
+
+ for k, coeff in h_part.items():
+ h_part[k] = simplify(coeff)
+
+ common = S.One
+
+ if not i_part.is_zero and not i_part.is_hypergeometric(n) and \
+ not (i_part.is_Add and all((x.is_hypergeometric(n) for x in i_part.expand().args))):
+ raise ValueError("The independent term should be a sum of hypergeometric functions, got '%s'" % i_part)
+
+ for coeff in h_part.values():
+ if coeff.is_rational_function(n):
+ if not coeff.is_polynomial(n):
+ common = lcm(common, coeff.as_numer_denom()[1], n)
+ else:
+ raise ValueError(
+ "Polynomial or rational function expected, got '%s'" % coeff)
+
+ i_numer, i_denom = i_part.as_numer_denom()
+
+ if i_denom.is_polynomial(n):
+ common = lcm(common, i_denom, n)
+
+ if common is not S.One:
+ for k, coeff in h_part.items():
+ numer, denom = coeff.as_numer_denom()
+ h_part[k] = numer*quo(common, denom, n)
+
+ i_part = i_numer*quo(common, i_denom, n)
+
+ K_min = min(h_part.keys())
+
+ if K_min < 0:
+ K = abs(K_min)
+
+ H_part = defaultdict(lambda: S.Zero)
+ i_part = i_part.subs(n, n + K).expand()
+ common = common.subs(n, n + K).expand()
+
+ for k, coeff in h_part.items():
+ H_part[k + K] = coeff.subs(n, n + K).expand()
+ else:
+ H_part = h_part
+
+ K_max = max(H_part.keys())
+ coeffs = [H_part[i] for i in range(K_max + 1)]
+
+ result = rsolve_hyper(coeffs, -i_part, n, symbols=True)
+
+ if result is None:
+ return None
+
+ solution, symbols = result
+
+ if init in ({}, []):
+ init = None
+
+ if symbols and init is not None:
+ if isinstance(init, list):
+ init = {i: init[i] for i in range(len(init))}
+
+ equations = []
+
+ for k, v in init.items():
+ try:
+ i = int(k)
+ except TypeError:
+ if k.is_Function and k.func == y.func:
+ i = int(k.args[0])
+ else:
+ raise ValueError("Integer or term expected, got '%s'" % k)
+
+ eq = solution.subs(n, i) - v
+ if eq.has(S.NaN):
+ eq = solution.limit(n, i) - v
+ equations.append(eq)
+
+ result = solve(equations, *symbols)
+
+ if not result:
+ return None
+ else:
+ solution = solution.subs(result)
+
+ return solution
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/solvers.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/solvers.py
new file mode 100644
index 0000000000000000000000000000000000000000..adc467fd43b636be6daf95a3427dcb9ed10e4a7a
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/solvers.py
@@ -0,0 +1,3636 @@
+"""
+This module contain solvers for all kinds of equations:
+
+ - algebraic or transcendental, use solve()
+
+ - recurrence, use rsolve()
+
+ - differential, use dsolve()
+
+ - nonlinear (numerically), use nsolve()
+ (you will need a good starting point)
+
+"""
+from __future__ import annotations
+
+from sympy.core import (S, Add, Symbol, Dummy, Expr, Mul)
+from sympy.core.assumptions import check_assumptions
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import (expand_mul, expand_log, Derivative,
+ AppliedUndef, UndefinedFunction, nfloat,
+ Function, expand_power_exp, _mexpand, expand,
+ expand_func)
+from sympy.core.logic import fuzzy_not
+from sympy.core.numbers import ilcm, Float, Rational, _illegal
+from sympy.core.power import integer_log, Pow
+from sympy.core.relational import Eq, Ne
+from sympy.core.sorting import ordered, default_sort_key
+from sympy.core.sympify import sympify, _sympify
+from sympy.core.traversal import preorder_traversal
+from sympy.logic.boolalg import And, BooleanAtom
+
+from sympy.functions import (log, exp, LambertW, cos, sin, tan, acos, asin, atan,
+ Abs, re, im, arg, sqrt, atan2)
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.elementary.hyperbolic import HyperbolicFunction
+from sympy.functions.elementary.piecewise import piecewise_fold, Piecewise
+from sympy.functions.elementary.trigonometric import TrigonometricFunction
+from sympy.integrals.integrals import Integral
+from sympy.ntheory.factor_ import divisors
+from sympy.simplify import (simplify, collect, powsimp, posify, # type: ignore
+ powdenest, nsimplify, denom, logcombine, sqrtdenest, fraction,
+ separatevars)
+from sympy.simplify.sqrtdenest import sqrt_depth
+from sympy.simplify.fu import TR1, TR2i
+from sympy.matrices.common import NonInvertibleMatrixError
+from sympy.matrices import Matrix, zeros
+from sympy.polys import roots, cancel, factor, Poly
+from sympy.polys.polyerrors import GeneratorsNeeded, PolynomialError
+from sympy.polys.solvers import sympy_eqs_to_ring, solve_lin_sys
+from sympy.utilities.lambdify import lambdify
+from sympy.utilities.misc import filldedent, debugf
+from sympy.utilities.iterables import (connected_components,
+ generate_bell, uniq, iterable, is_sequence, subsets, flatten)
+from sympy.utilities.decorator import conserve_mpmath_dps
+
+from mpmath import findroot
+
+from sympy.solvers.polysys import solve_poly_system
+
+from types import GeneratorType
+from collections import defaultdict
+from itertools import combinations, product
+
+import warnings
+
+
+def recast_to_symbols(eqs, symbols):
+ """
+ Return (e, s, d) where e and s are versions of *eqs* and
+ *symbols* in which any non-Symbol objects in *symbols* have
+ been replaced with generic Dummy symbols and d is a dictionary
+ that can be used to restore the original expressions.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.solvers import recast_to_symbols
+ >>> from sympy import symbols, Function
+ >>> x, y = symbols('x y')
+ >>> fx = Function('f')(x)
+ >>> eqs, syms = [fx + 1, x, y], [fx, y]
+ >>> e, s, d = recast_to_symbols(eqs, syms); (e, s, d)
+ ([_X0 + 1, x, y], [_X0, y], {_X0: f(x)})
+
+ The original equations and symbols can be restored using d:
+
+ >>> assert [i.xreplace(d) for i in eqs] == eqs
+ >>> assert [d.get(i, i) for i in s] == syms
+
+ """
+ if not iterable(eqs) and iterable(symbols):
+ raise ValueError('Both eqs and symbols must be iterable')
+ orig = list(symbols)
+ symbols = list(ordered(symbols))
+ swap_sym = {}
+ i = 0
+ for j, s in enumerate(symbols):
+ if not isinstance(s, Symbol) and s not in swap_sym:
+ swap_sym[s] = Dummy('X%d' % i)
+ i += 1
+ new_f = []
+ for i in eqs:
+ isubs = getattr(i, 'subs', None)
+ if isubs is not None:
+ new_f.append(isubs(swap_sym))
+ else:
+ new_f.append(i)
+ restore = {v: k for k, v in swap_sym.items()}
+ return new_f, [swap_sym.get(i, i) for i in orig], restore
+
+
+def _ispow(e):
+ """Return True if e is a Pow or is exp."""
+ return isinstance(e, Expr) and (e.is_Pow or isinstance(e, exp))
+
+
+def _simple_dens(f, symbols):
+ # when checking if a denominator is zero, we can just check the
+ # base of powers with nonzero exponents since if the base is zero
+ # the power will be zero, too. To keep it simple and fast, we
+ # limit simplification to exponents that are Numbers
+ dens = set()
+ for d in denoms(f, symbols):
+ if d.is_Pow and d.exp.is_Number:
+ if d.exp.is_zero:
+ continue # foo**0 is never 0
+ d = d.base
+ dens.add(d)
+ return dens
+
+
+def denoms(eq, *symbols):
+ """
+ Return (recursively) set of all denominators that appear in *eq*
+ that contain any symbol in *symbols*; if *symbols* are not
+ provided then all denominators will be returned.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.solvers import denoms
+ >>> from sympy.abc import x, y, z
+
+ >>> denoms(x/y)
+ {y}
+
+ >>> denoms(x/(y*z))
+ {y, z}
+
+ >>> denoms(3/x + y/z)
+ {x, z}
+
+ >>> denoms(x/2 + y/z)
+ {2, z}
+
+ If *symbols* are provided then only denominators containing
+ those symbols will be returned:
+
+ >>> denoms(1/x + 1/y + 1/z, y, z)
+ {y, z}
+
+ """
+
+ pot = preorder_traversal(eq)
+ dens = set()
+ for p in pot:
+ # Here p might be Tuple or Relational
+ # Expr subtrees (e.g. lhs and rhs) will be traversed after by pot
+ if not isinstance(p, Expr):
+ continue
+ den = denom(p)
+ if den is S.One:
+ continue
+ for d in Mul.make_args(den):
+ dens.add(d)
+ if not symbols:
+ return dens
+ elif len(symbols) == 1:
+ if iterable(symbols[0]):
+ symbols = symbols[0]
+ return {d for d in dens if any(s in d.free_symbols for s in symbols)}
+
+
+def checksol(f, symbol, sol=None, **flags):
+ """
+ Checks whether sol is a solution of equation f == 0.
+
+ Explanation
+ ===========
+
+ Input can be either a single symbol and corresponding value
+ or a dictionary of symbols and values. When given as a dictionary
+ and flag ``simplify=True``, the values in the dictionary will be
+ simplified. *f* can be a single equation or an iterable of equations.
+ A solution must satisfy all equations in *f* to be considered valid;
+ if a solution does not satisfy any equation, False is returned; if one or
+ more checks are inconclusive (and none are False) then None is returned.
+
+ Examples
+ ========
+
+ >>> from sympy import checksol, symbols
+ >>> x, y = symbols('x,y')
+ >>> checksol(x**4 - 1, x, 1)
+ True
+ >>> checksol(x**4 - 1, x, 0)
+ False
+ >>> checksol(x**2 + y**2 - 5**2, {x: 3, y: 4})
+ True
+
+ To check if an expression is zero using ``checksol()``, pass it
+ as *f* and send an empty dictionary for *symbol*:
+
+ >>> checksol(x**2 + x - x*(x + 1), {})
+ True
+
+ None is returned if ``checksol()`` could not conclude.
+
+ flags:
+ 'numerical=True (default)'
+ do a fast numerical check if ``f`` has only one symbol.
+ 'minimal=True (default is False)'
+ a very fast, minimal testing.
+ 'warn=True (default is False)'
+ show a warning if checksol() could not conclude.
+ 'simplify=True (default)'
+ simplify solution before substituting into function and
+ simplify the function before trying specific simplifications
+ 'force=True (default is False)'
+ make positive all symbols without assumptions regarding sign.
+
+ """
+ from sympy.physics.units import Unit
+
+ minimal = flags.get('minimal', False)
+
+ if sol is not None:
+ sol = {symbol: sol}
+ elif isinstance(symbol, dict):
+ sol = symbol
+ else:
+ msg = 'Expecting (sym, val) or ({sym: val}, None) but got (%s, %s)'
+ raise ValueError(msg % (symbol, sol))
+
+ if iterable(f):
+ if not f:
+ raise ValueError('no functions to check')
+ rv = True
+ for fi in f:
+ check = checksol(fi, sol, **flags)
+ if check:
+ continue
+ if check is False:
+ return False
+ rv = None # don't return, wait to see if there's a False
+ return rv
+
+ f = _sympify(f)
+
+ if f.is_number:
+ return f.is_zero
+
+ if isinstance(f, Poly):
+ f = f.as_expr()
+ elif isinstance(f, (Eq, Ne)):
+ if f.rhs in (S.true, S.false):
+ f = f.reversed
+ B, E = f.args
+ if isinstance(B, BooleanAtom):
+ f = f.subs(sol)
+ if not f.is_Boolean:
+ return
+ else:
+ f = f.rewrite(Add, evaluate=False, deep=False)
+
+ if isinstance(f, BooleanAtom):
+ return bool(f)
+ elif not f.is_Relational and not f:
+ return True
+
+ illegal = set(_illegal)
+ if any(sympify(v).atoms() & illegal for k, v in sol.items()):
+ return False
+
+ attempt = -1
+ numerical = flags.get('numerical', True)
+ while 1:
+ attempt += 1
+ if attempt == 0:
+ val = f.subs(sol)
+ if isinstance(val, Mul):
+ val = val.as_independent(Unit)[0]
+ if val.atoms() & illegal:
+ return False
+ elif attempt == 1:
+ if not val.is_number:
+ if not val.is_constant(*list(sol.keys()), simplify=not minimal):
+ return False
+ # there are free symbols -- simple expansion might work
+ _, val = val.as_content_primitive()
+ val = _mexpand(val.as_numer_denom()[0], recursive=True)
+ elif attempt == 2:
+ if minimal:
+ return
+ if flags.get('simplify', True):
+ for k in sol:
+ sol[k] = simplify(sol[k])
+ # start over without the failed expanded form, possibly
+ # with a simplified solution
+ val = simplify(f.subs(sol))
+ if flags.get('force', True):
+ val, reps = posify(val)
+ # expansion may work now, so try again and check
+ exval = _mexpand(val, recursive=True)
+ if exval.is_number:
+ # we can decide now
+ val = exval
+ else:
+ # if there are no radicals and no functions then this can't be
+ # zero anymore -- can it?
+ pot = preorder_traversal(expand_mul(val))
+ seen = set()
+ saw_pow_func = False
+ for p in pot:
+ if p in seen:
+ continue
+ seen.add(p)
+ if p.is_Pow and not p.exp.is_Integer:
+ saw_pow_func = True
+ elif p.is_Function:
+ saw_pow_func = True
+ elif isinstance(p, UndefinedFunction):
+ saw_pow_func = True
+ if saw_pow_func:
+ break
+ if saw_pow_func is False:
+ return False
+ if flags.get('force', True):
+ # don't do a zero check with the positive assumptions in place
+ val = val.subs(reps)
+ nz = fuzzy_not(val.is_zero)
+ if nz is not None:
+ # issue 5673: nz may be True even when False
+ # so these are just hacks to keep a false positive
+ # from being returned
+
+ # HACK 1: LambertW (issue 5673)
+ if val.is_number and val.has(LambertW):
+ # don't eval this to verify solution since if we got here,
+ # numerical must be False
+ return None
+
+ # add other HACKs here if necessary, otherwise we assume
+ # the nz value is correct
+ return not nz
+ break
+ if val.is_Rational:
+ return val == 0
+ if numerical and val.is_number:
+ return (abs(val.n(18).n(12, chop=True)) < 1e-9) is S.true
+
+ if flags.get('warn', False):
+ warnings.warn("\n\tWarning: could not verify solution %s." % sol)
+ # returns None if it can't conclude
+ # TODO: improve solution testing
+
+
+def solve(f, *symbols, **flags):
+ r"""
+ Algebraically solves equations and systems of equations.
+
+ Explanation
+ ===========
+
+ Currently supported:
+ - polynomial
+ - transcendental
+ - piecewise combinations of the above
+ - systems of linear and polynomial equations
+ - systems containing relational expressions
+ - systems implied by undetermined coefficients
+
+ Examples
+ ========
+
+ The default output varies according to the input and might
+ be a list (possibly empty), a dictionary, a list of
+ dictionaries or tuples, or an expression involving relationals.
+ For specifics regarding different forms of output that may appear, see :ref:`solve_output`.
+ Let it suffice here to say that to obtain a uniform output from
+ `solve` use ``dict=True`` or ``set=True`` (see below).
+
+ >>> from sympy import solve, Poly, Eq, Matrix, Symbol
+ >>> from sympy.abc import x, y, z, a, b
+
+ The expressions that are passed can be Expr, Equality, or Poly
+ classes (or lists of the same); a Matrix is considered to be a
+ list of all the elements of the matrix:
+
+ >>> solve(x - 3, x)
+ [3]
+ >>> solve(Eq(x, 3), x)
+ [3]
+ >>> solve(Poly(x - 3), x)
+ [3]
+ >>> solve(Matrix([[x, x + y]]), x, y) == solve([x, x + y], x, y)
+ True
+
+ If no symbols are indicated to be of interest and the equation is
+ univariate, a list of values is returned; otherwise, the keys in
+ a dictionary will indicate which (of all the variables used in
+ the expression(s)) variables and solutions were found:
+
+ >>> solve(x**2 - 4)
+ [-2, 2]
+ >>> solve((x - a)*(y - b))
+ [{a: x}, {b: y}]
+ >>> solve([x - 3, y - 1])
+ {x: 3, y: 1}
+ >>> solve([x - 3, y**2 - 1])
+ [{x: 3, y: -1}, {x: 3, y: 1}]
+
+ If you pass symbols for which solutions are sought, the output will vary
+ depending on the number of symbols you passed, whether you are passing
+ a list of expressions or not, and whether a linear system was solved.
+ Uniform output is attained by using ``dict=True`` or ``set=True``.
+
+ >>> #### *** feel free to skip to the stars below *** ####
+ >>> from sympy import TableForm
+ >>> h = [None, ';|;'.join(['e', 's', 'solve(e, s)', 'solve(e, s, dict=True)',
+ ... 'solve(e, s, set=True)']).split(';')]
+ >>> t = []
+ >>> for e, s in [
+ ... (x - y, y),
+ ... (x - y, [x, y]),
+ ... (x**2 - y, [x, y]),
+ ... ([x - 3, y -1], [x, y]),
+ ... ]:
+ ... how = [{}, dict(dict=True), dict(set=True)]
+ ... res = [solve(e, s, **f) for f in how]
+ ... t.append([e, '|', s, '|'] + [res[0], '|', res[1], '|', res[2]])
+ ...
+ >>> # ******************************************************* #
+ >>> TableForm(t, headings=h, alignments="<")
+ e | s | solve(e, s) | solve(e, s, dict=True) | solve(e, s, set=True)
+ ---------------------------------------------------------------------------------------
+ x - y | y | [x] | [{y: x}] | ([y], {(x,)})
+ x - y | [x, y] | [(y, y)] | [{x: y}] | ([x, y], {(y, y)})
+ x**2 - y | [x, y] | [(x, x**2)] | [{y: x**2}] | ([x, y], {(x, x**2)})
+ [x - 3, y - 1] | [x, y] | {x: 3, y: 1} | [{x: 3, y: 1}] | ([x, y], {(3, 1)})
+
+ * If any equation does not depend on the symbol(s) given, it will be
+ eliminated from the equation set and an answer may be given
+ implicitly in terms of variables that were not of interest:
+
+ >>> solve([x - y, y - 3], x)
+ {x: y}
+
+ When you pass all but one of the free symbols, an attempt
+ is made to find a single solution based on the method of
+ undetermined coefficients. If it succeeds, a dictionary of values
+ is returned. If you want an algebraic solutions for one
+ or more of the symbols, pass the expression to be solved in a list:
+
+ >>> e = a*x + b - 2*x - 3
+ >>> solve(e, [a, b])
+ {a: 2, b: 3}
+ >>> solve([e], [a, b])
+ {a: -b/x + (2*x + 3)/x}
+
+ When there is no solution for any given symbol which will make all
+ expressions zero, the empty list is returned (or an empty set in
+ the tuple when ``set=True``):
+
+ >>> from sympy import sqrt
+ >>> solve(3, x)
+ []
+ >>> solve(x - 3, y)
+ []
+ >>> solve(sqrt(x) + 1, x, set=True)
+ ([x], set())
+
+ When an object other than a Symbol is given as a symbol, it is
+ isolated algebraically and an implicit solution may be obtained.
+ This is mostly provided as a convenience to save you from replacing
+ the object with a Symbol and solving for that Symbol. It will only
+ work if the specified object can be replaced with a Symbol using the
+ subs method:
+
+ >>> from sympy import exp, Function
+ >>> f = Function('f')
+
+ >>> solve(f(x) - x, f(x))
+ [x]
+ >>> solve(f(x).diff(x) - f(x) - x, f(x).diff(x))
+ [x + f(x)]
+ >>> solve(f(x).diff(x) - f(x) - x, f(x))
+ [-x + Derivative(f(x), x)]
+ >>> solve(x + exp(x)**2, exp(x), set=True)
+ ([exp(x)], {(-sqrt(-x),), (sqrt(-x),)})
+
+ >>> from sympy import Indexed, IndexedBase, Tuple
+ >>> A = IndexedBase('A')
+ >>> eqs = Tuple(A[1] + A[2] - 3, A[1] - A[2] + 1)
+ >>> solve(eqs, eqs.atoms(Indexed))
+ {A[1]: 1, A[2]: 2}
+
+ * To solve for a function within a derivative, use :func:`~.dsolve`.
+
+ To solve for a symbol implicitly, use implicit=True:
+
+ >>> solve(x + exp(x), x)
+ [-LambertW(1)]
+ >>> solve(x + exp(x), x, implicit=True)
+ [-exp(x)]
+
+ It is possible to solve for anything in an expression that can be
+ replaced with a symbol using :obj:`~sympy.core.basic.Basic.subs`:
+
+ >>> solve(x + 2 + sqrt(3), x + 2)
+ [-sqrt(3)]
+ >>> solve((x + 2 + sqrt(3), x + 4 + y), y, x + 2)
+ {y: -2 + sqrt(3), x + 2: -sqrt(3)}
+
+ * Nothing heroic is done in this implicit solving so you may end up
+ with a symbol still in the solution:
+
+ >>> eqs = (x*y + 3*y + sqrt(3), x + 4 + y)
+ >>> solve(eqs, y, x + 2)
+ {y: -sqrt(3)/(x + 3), x + 2: -2*x/(x + 3) - 6/(x + 3) + sqrt(3)/(x + 3)}
+ >>> solve(eqs, y*x, x)
+ {x: -y - 4, x*y: -3*y - sqrt(3)}
+
+ * If you attempt to solve for a number, remember that the number
+ you have obtained does not necessarily mean that the value is
+ equivalent to the expression obtained:
+
+ >>> solve(sqrt(2) - 1, 1)
+ [sqrt(2)]
+ >>> solve(x - y + 1, 1) # /!\ -1 is targeted, too
+ [x/(y - 1)]
+ >>> [_.subs(z, -1) for _ in solve((x - y + 1).subs(-1, z), 1)]
+ [-x + y]
+
+ **Additional Examples**
+
+ ``solve()`` with check=True (default) will run through the symbol tags to
+ eliminate unwanted solutions. If no assumptions are included, all possible
+ solutions will be returned:
+
+ >>> x = Symbol("x")
+ >>> solve(x**2 - 1)
+ [-1, 1]
+
+ By setting the ``positive`` flag, only one solution will be returned:
+
+ >>> pos = Symbol("pos", positive=True)
+ >>> solve(pos**2 - 1)
+ [1]
+
+ When the solutions are checked, those that make any denominator zero
+ are automatically excluded. If you do not want to exclude such solutions,
+ then use the check=False option:
+
+ >>> from sympy import sin, limit
+ >>> solve(sin(x)/x) # 0 is excluded
+ [pi]
+
+ If ``check=False``, then a solution to the numerator being zero is found
+ but the value of $x = 0$ is a spurious solution since $\sin(x)/x$ has the well
+ known limit (without discontinuity) of 1 at $x = 0$:
+
+ >>> solve(sin(x)/x, check=False)
+ [0, pi]
+
+ In the following case, however, the limit exists and is equal to the
+ value of $x = 0$ that is excluded when check=True:
+
+ >>> eq = x**2*(1/x - z**2/x)
+ >>> solve(eq, x)
+ []
+ >>> solve(eq, x, check=False)
+ [0]
+ >>> limit(eq, x, 0, '-')
+ 0
+ >>> limit(eq, x, 0, '+')
+ 0
+
+ **Solving Relationships**
+
+ When one or more expressions passed to ``solve`` is a relational,
+ a relational result is returned (and the ``dict`` and ``set`` flags
+ are ignored):
+
+ >>> solve(x < 3)
+ (-oo < x) & (x < 3)
+ >>> solve([x < 3, x**2 > 4], x)
+ ((-oo < x) & (x < -2)) | ((2 < x) & (x < 3))
+ >>> solve([x + y - 3, x > 3], x)
+ (3 < x) & (x < oo) & Eq(x, 3 - y)
+
+ Although checking of assumptions on symbols in relationals
+ is not done, setting assumptions will affect how certain
+ relationals might automatically simplify:
+
+ >>> solve(x**2 > 4)
+ ((-oo < x) & (x < -2)) | ((2 < x) & (x < oo))
+
+ >>> r = Symbol('r', real=True)
+ >>> solve(r**2 > 4)
+ (2 < r) | (r < -2)
+
+ There is currently no algorithm in SymPy that allows you to use
+ relationships to resolve more than one variable. So the following
+ does not determine that ``q < 0`` (and trying to solve for ``r``
+ and ``q`` will raise an error):
+
+ >>> from sympy import symbols
+ >>> r, q = symbols('r, q', real=True)
+ >>> solve([r + q - 3, r > 3], r)
+ (3 < r) & Eq(r, 3 - q)
+
+ You can directly call the routine that ``solve`` calls
+ when it encounters a relational: :func:`~.reduce_inequalities`.
+ It treats Expr like Equality.
+
+ >>> from sympy import reduce_inequalities
+ >>> reduce_inequalities([x**2 - 4])
+ Eq(x, -2) | Eq(x, 2)
+
+ If each relationship contains only one symbol of interest,
+ the expressions can be processed for multiple symbols:
+
+ >>> reduce_inequalities([0 <= x - 1, y < 3], [x, y])
+ (-oo < y) & (1 <= x) & (x < oo) & (y < 3)
+
+ But an error is raised if any relationship has more than one
+ symbol of interest:
+
+ >>> reduce_inequalities([0 <= x*y - 1, y < 3], [x, y])
+ Traceback (most recent call last):
+ ...
+ NotImplementedError:
+ inequality has more than one symbol of interest.
+
+ **Disabling High-Order Explicit Solutions**
+
+ When solving polynomial expressions, you might not want explicit solutions
+ (which can be quite long). If the expression is univariate, ``CRootOf``
+ instances will be returned instead:
+
+ >>> solve(x**3 - x + 1)
+ [-1/((-1/2 - sqrt(3)*I/2)*(3*sqrt(69)/2 + 27/2)**(1/3)) -
+ (-1/2 - sqrt(3)*I/2)*(3*sqrt(69)/2 + 27/2)**(1/3)/3,
+ -(-1/2 + sqrt(3)*I/2)*(3*sqrt(69)/2 + 27/2)**(1/3)/3 -
+ 1/((-1/2 + sqrt(3)*I/2)*(3*sqrt(69)/2 + 27/2)**(1/3)),
+ -(3*sqrt(69)/2 + 27/2)**(1/3)/3 -
+ 1/(3*sqrt(69)/2 + 27/2)**(1/3)]
+ >>> solve(x**3 - x + 1, cubics=False)
+ [CRootOf(x**3 - x + 1, 0),
+ CRootOf(x**3 - x + 1, 1),
+ CRootOf(x**3 - x + 1, 2)]
+
+ If the expression is multivariate, no solution might be returned:
+
+ >>> solve(x**3 - x + a, x, cubics=False)
+ []
+
+ Sometimes solutions will be obtained even when a flag is False because the
+ expression could be factored. In the following example, the equation can
+ be factored as the product of a linear and a quadratic factor so explicit
+ solutions (which did not require solving a cubic expression) are obtained:
+
+ >>> eq = x**3 + 3*x**2 + x - 1
+ >>> solve(eq, cubics=False)
+ [-1, -1 + sqrt(2), -sqrt(2) - 1]
+
+ **Solving Equations Involving Radicals**
+
+ Because of SymPy's use of the principle root, some solutions
+ to radical equations will be missed unless check=False:
+
+ >>> from sympy import root
+ >>> eq = root(x**3 - 3*x**2, 3) + 1 - x
+ >>> solve(eq)
+ []
+ >>> solve(eq, check=False)
+ [1/3]
+
+ In the above example, there is only a single solution to the
+ equation. Other expressions will yield spurious roots which
+ must be checked manually; roots which give a negative argument
+ to odd-powered radicals will also need special checking:
+
+ >>> from sympy import real_root, S
+ >>> eq = root(x, 3) - root(x, 5) + S(1)/7
+ >>> solve(eq) # this gives 2 solutions but misses a 3rd
+ [CRootOf(7*x**5 - 7*x**3 + 1, 1)**15,
+ CRootOf(7*x**5 - 7*x**3 + 1, 2)**15]
+ >>> sol = solve(eq, check=False)
+ >>> [abs(eq.subs(x,i).n(2)) for i in sol]
+ [0.48, 0.e-110, 0.e-110, 0.052, 0.052]
+
+ The first solution is negative so ``real_root`` must be used to see that it
+ satisfies the expression:
+
+ >>> abs(real_root(eq.subs(x, sol[0])).n(2))
+ 0.e-110
+
+ If the roots of the equation are not real then more care will be
+ necessary to find the roots, especially for higher order equations.
+ Consider the following expression:
+
+ >>> expr = root(x, 3) - root(x, 5)
+
+ We will construct a known value for this expression at x = 3 by selecting
+ the 1-th root for each radical:
+
+ >>> expr1 = root(x, 3, 1) - root(x, 5, 1)
+ >>> v = expr1.subs(x, -3)
+
+ The ``solve`` function is unable to find any exact roots to this equation:
+
+ >>> eq = Eq(expr, v); eq1 = Eq(expr1, v)
+ >>> solve(eq, check=False), solve(eq1, check=False)
+ ([], [])
+
+ The function ``unrad``, however, can be used to get a form of the equation
+ for which numerical roots can be found:
+
+ >>> from sympy.solvers.solvers import unrad
+ >>> from sympy import nroots
+ >>> e, (p, cov) = unrad(eq)
+ >>> pvals = nroots(e)
+ >>> inversion = solve(cov, x)[0]
+ >>> xvals = [inversion.subs(p, i) for i in pvals]
+
+ Although ``eq`` or ``eq1`` could have been used to find ``xvals``, the
+ solution can only be verified with ``expr1``:
+
+ >>> z = expr - v
+ >>> [xi.n(chop=1e-9) for xi in xvals if abs(z.subs(x, xi).n()) < 1e-9]
+ []
+ >>> z1 = expr1 - v
+ >>> [xi.n(chop=1e-9) for xi in xvals if abs(z1.subs(x, xi).n()) < 1e-9]
+ [-3.0]
+
+ Parameters
+ ==========
+
+ f :
+ - a single Expr or Poly that must be zero
+ - an Equality
+ - a Relational expression
+ - a Boolean
+ - iterable of one or more of the above
+
+ symbols : (object(s) to solve for) specified as
+ - none given (other non-numeric objects will be used)
+ - single symbol
+ - denested list of symbols
+ (e.g., ``solve(f, x, y)``)
+ - ordered iterable of symbols
+ (e.g., ``solve(f, [x, y])``)
+
+ flags :
+ dict=True (default is False)
+ Return list (perhaps empty) of solution mappings.
+ set=True (default is False)
+ Return list of symbols and set of tuple(s) of solution(s).
+ exclude=[] (default)
+ Do not try to solve for any of the free symbols in exclude;
+ if expressions are given, the free symbols in them will
+ be extracted automatically.
+ check=True (default)
+ If False, do not do any testing of solutions. This can be
+ useful if you want to include solutions that make any
+ denominator zero.
+ numerical=True (default)
+ Do a fast numerical check if *f* has only one symbol.
+ minimal=True (default is False)
+ A very fast, minimal testing.
+ warn=True (default is False)
+ Show a warning if ``checksol()`` could not conclude.
+ simplify=True (default)
+ Simplify all but polynomials of order 3 or greater before
+ returning them and (if check is not False) use the
+ general simplify function on the solutions and the
+ expression obtained when they are substituted into the
+ function which should be zero.
+ force=True (default is False)
+ Make positive all symbols without assumptions regarding sign.
+ rational=True (default)
+ Recast Floats as Rational; if this option is not used, the
+ system containing Floats may fail to solve because of issues
+ with polys. If rational=None, Floats will be recast as
+ rationals but the answer will be recast as Floats. If the
+ flag is False then nothing will be done to the Floats.
+ manual=True (default is False)
+ Do not use the polys/matrix method to solve a system of
+ equations, solve them one at a time as you might "manually."
+ implicit=True (default is False)
+ Allows ``solve`` to return a solution for a pattern in terms of
+ other functions that contain that pattern; this is only
+ needed if the pattern is inside of some invertible function
+ like cos, exp, ect.
+ particular=True (default is False)
+ Instructs ``solve`` to try to find a particular solution to
+ a linear system with as many zeros as possible; this is very
+ expensive.
+ quick=True (default is False; ``particular`` must be True)
+ Selects a fast heuristic to find a solution with many zeros
+ whereas a value of False uses the very slow method guaranteed
+ to find the largest number of zeros possible.
+ cubics=True (default)
+ Return explicit solutions when cubic expressions are encountered.
+ When False, quartics and quintics are disabled, too.
+ quartics=True (default)
+ Return explicit solutions when quartic expressions are encountered.
+ When False, quintics are disabled, too.
+ quintics=True (default)
+ Return explicit solutions (if possible) when quintic expressions
+ are encountered.
+
+ See Also
+ ========
+
+ rsolve: For solving recurrence relationships
+ dsolve: For solving differential equations
+
+ """
+ from .inequalities import reduce_inequalities
+
+ # checking/recording flags
+ ###########################################################################
+
+ # set solver types explicitly; as soon as one is False
+ # all the rest will be False
+ hints = ('cubics', 'quartics', 'quintics')
+ default = True
+ for k in hints:
+ default = flags.setdefault(k, bool(flags.get(k, default)))
+
+ # allow solution to contain symbol if True:
+ implicit = flags.get('implicit', False)
+
+ # record desire to see warnings
+ warn = flags.get('warn', False)
+
+ # this flag will be needed for quick exits below, so record
+ # now -- but don't record `dict` yet since it might change
+ as_set = flags.get('set', False)
+
+ # keeping track of how f was passed
+ bare_f = not iterable(f)
+
+ # check flag usage for particular/quick which should only be used
+ # with systems of equations
+ if flags.get('quick', None) is not None:
+ if not flags.get('particular', None):
+ raise ValueError('when using `quick`, `particular` should be True')
+ if flags.get('particular', False) and bare_f:
+ raise ValueError(filldedent("""
+ The 'particular/quick' flag is usually used with systems of
+ equations. Either pass your equation in a list or
+ consider using a solver like `diophantine` if you are
+ looking for a solution in integers."""))
+
+ # sympify everything, creating list of expressions and list of symbols
+ ###########################################################################
+
+ def _sympified_list(w):
+ return list(map(sympify, w if iterable(w) else [w]))
+ f, symbols = (_sympified_list(w) for w in [f, symbols])
+
+ # preprocess symbol(s)
+ ###########################################################################
+
+ ordered_symbols = None # were the symbols in a well defined order?
+ if not symbols:
+ # get symbols from equations
+ symbols = set().union(*[fi.free_symbols for fi in f])
+ if len(symbols) < len(f):
+ for fi in f:
+ pot = preorder_traversal(fi)
+ for p in pot:
+ if isinstance(p, AppliedUndef):
+ if not as_set:
+ flags['dict'] = True # better show symbols
+ symbols.add(p)
+ pot.skip() # don't go any deeper
+ ordered_symbols = False
+ symbols = list(ordered(symbols)) # to make it canonical
+ else:
+ if len(symbols) == 1 and iterable(symbols[0]):
+ symbols = symbols[0]
+ ordered_symbols = symbols and is_sequence(symbols,
+ include=GeneratorType)
+ _symbols = list(uniq(symbols))
+ if len(_symbols) != len(symbols):
+ ordered_symbols = False
+ symbols = list(ordered(symbols))
+ else:
+ symbols = _symbols
+
+ # check for duplicates
+ if len(symbols) != len(set(symbols)):
+ raise ValueError('duplicate symbols given')
+ # remove those not of interest
+ exclude = flags.pop('exclude', set())
+ if exclude:
+ if isinstance(exclude, Expr):
+ exclude = [exclude]
+ exclude = set().union(*[e.free_symbols for e in sympify(exclude)])
+ symbols = [s for s in symbols if s not in exclude]
+
+ # preprocess equation(s)
+ ###########################################################################
+
+ # automatically ignore True values
+ if isinstance(f, list):
+ f = [s for s in f if s is not S.true]
+
+ # handle canonicalization of equation types
+ for i, fi in enumerate(f):
+ if isinstance(fi, (Eq, Ne)):
+ if 'ImmutableDenseMatrix' in [type(a).__name__ for a in fi.args]:
+ fi = fi.lhs - fi.rhs
+ else:
+ L, R = fi.args
+ if isinstance(R, BooleanAtom):
+ L, R = R, L
+ if isinstance(L, BooleanAtom):
+ if isinstance(fi, Ne):
+ L = ~L
+ if R.is_Relational:
+ fi = ~R if L is S.false else R
+ elif R.is_Symbol:
+ return L
+ elif R.is_Boolean and (~R).is_Symbol:
+ return ~L
+ else:
+ raise NotImplementedError(filldedent('''
+ Unanticipated argument of Eq when other arg
+ is True or False.
+ '''))
+ else:
+ fi = fi.rewrite(Add, evaluate=False, deep=False)
+ f[i] = fi
+
+ # *** dispatch and handle as a system of relationals
+ # **************************************************
+ if fi.is_Relational:
+ if len(symbols) != 1:
+ raise ValueError("can only solve for one symbol at a time")
+ if warn and symbols[0].assumptions0:
+ warnings.warn(filldedent("""
+ \tWarning: assumptions about variable '%s' are
+ not handled currently.""" % symbols[0]))
+ return reduce_inequalities(f, symbols=symbols)
+
+ # convert Poly to expression
+ if isinstance(fi, Poly):
+ f[i] = fi.as_expr()
+
+ # rewrite hyperbolics in terms of exp if they have symbols of
+ # interest
+ f[i] = f[i].replace(lambda w: isinstance(w, HyperbolicFunction) and \
+ w.has_free(*symbols), lambda w: w.rewrite(exp))
+
+ # if we have a Matrix, we need to iterate over its elements again
+ if f[i].is_Matrix:
+ bare_f = False
+ f.extend(list(f[i]))
+ f[i] = S.Zero
+
+ # if we can split it into real and imaginary parts then do so
+ freei = f[i].free_symbols
+ if freei and all(s.is_extended_real or s.is_imaginary for s in freei):
+ fr, fi = f[i].as_real_imag()
+ # accept as long as new re, im, arg or atan2 are not introduced
+ had = f[i].atoms(re, im, arg, atan2)
+ if fr and fi and fr != fi and not any(
+ i.atoms(re, im, arg, atan2) - had for i in (fr, fi)):
+ if bare_f:
+ bare_f = False
+ f[i: i + 1] = [fr, fi]
+
+ # real/imag handling -----------------------------
+ if any(isinstance(fi, (bool, BooleanAtom)) for fi in f):
+ if as_set:
+ return [], set()
+ return []
+
+ for i, fi in enumerate(f):
+ # Abs
+ while True:
+ was = fi
+ fi = fi.replace(Abs, lambda arg:
+ separatevars(Abs(arg)).rewrite(Piecewise) if arg.has(*symbols)
+ else Abs(arg))
+ if was == fi:
+ break
+
+ for e in fi.find(Abs):
+ if e.has(*symbols):
+ raise NotImplementedError('solving %s when the argument '
+ 'is not real or imaginary.' % e)
+
+ # arg
+ fi = fi.replace(arg, lambda a: arg(a).rewrite(atan2).rewrite(atan))
+
+ # save changes
+ f[i] = fi
+
+ # see if re(s) or im(s) appear
+ freim = [fi for fi in f if fi.has(re, im)]
+ if freim:
+ irf = []
+ for s in symbols:
+ if s.is_real or s.is_imaginary:
+ continue # neither re(x) nor im(x) will appear
+ # if re(s) or im(s) appear, the auxiliary equation must be present
+ if any(fi.has(re(s), im(s)) for fi in freim):
+ irf.append((s, re(s) + S.ImaginaryUnit*im(s)))
+ if irf:
+ for s, rhs in irf:
+ f = [fi.xreplace({s: rhs}) for fi in f] + [s - rhs]
+ symbols.extend([re(s), im(s)])
+ if bare_f:
+ bare_f = False
+ flags['dict'] = True
+ # end of real/imag handling -----------------------------
+
+ # we can solve for non-symbol entities by replacing them with Dummy symbols
+ f, symbols, swap_sym = recast_to_symbols(f, symbols)
+ # this set of symbols (perhaps recast) is needed below
+ symset = set(symbols)
+
+ # get rid of equations that have no symbols of interest; we don't
+ # try to solve them because the user didn't ask and they might be
+ # hard to solve; this means that solutions may be given in terms
+ # of the eliminated equations e.g. solve((x-y, y-3), x) -> {x: y}
+ newf = []
+ for fi in f:
+ # let the solver handle equations that..
+ # - have no symbols but are expressions
+ # - have symbols of interest
+ # - have no symbols of interest but are constant
+ # but when an expression is not constant and has no symbols of
+ # interest, it can't change what we obtain for a solution from
+ # the remaining equations so we don't include it; and if it's
+ # zero it can be removed and if it's not zero, there is no
+ # solution for the equation set as a whole
+ #
+ # The reason for doing this filtering is to allow an answer
+ # to be obtained to queries like solve((x - y, y), x); without
+ # this mod the return value is []
+ ok = False
+ if fi.free_symbols & symset:
+ ok = True
+ else:
+ if fi.is_number:
+ if fi.is_Number:
+ if fi.is_zero:
+ continue
+ return []
+ ok = True
+ else:
+ if fi.is_constant():
+ ok = True
+ if ok:
+ newf.append(fi)
+ if not newf:
+ if as_set:
+ return symbols, set()
+ return []
+ f = newf
+ del newf
+
+ # mask off any Object that we aren't going to invert: Derivative,
+ # Integral, etc... so that solving for anything that they contain will
+ # give an implicit solution
+ seen = set()
+ non_inverts = set()
+ for fi in f:
+ pot = preorder_traversal(fi)
+ for p in pot:
+ if not isinstance(p, Expr) or isinstance(p, Piecewise):
+ pass
+ elif (isinstance(p, bool) or
+ not p.args or
+ p in symset or
+ p.is_Add or p.is_Mul or
+ p.is_Pow and not implicit or
+ p.is_Function and not implicit) and p.func not in (re, im):
+ continue
+ elif p not in seen:
+ seen.add(p)
+ if p.free_symbols & symset:
+ non_inverts.add(p)
+ else:
+ continue
+ pot.skip()
+ del seen
+ non_inverts = dict(list(zip(non_inverts, [Dummy() for _ in non_inverts])))
+ f = [fi.subs(non_inverts) for fi in f]
+
+ # Both xreplace and subs are needed below: xreplace to force substitution
+ # inside Derivative, subs to handle non-straightforward substitutions
+ non_inverts = [(v, k.xreplace(swap_sym).subs(swap_sym)) for k, v in non_inverts.items()]
+
+ # rationalize Floats
+ floats = False
+ if flags.get('rational', True) is not False:
+ for i, fi in enumerate(f):
+ if fi.has(Float):
+ floats = True
+ f[i] = nsimplify(fi, rational=True)
+
+ # capture any denominators before rewriting since
+ # they may disappear after the rewrite, e.g. issue 14779
+ flags['_denominators'] = _simple_dens(f[0], symbols)
+
+ # Any embedded piecewise functions need to be brought out to the
+ # top level so that the appropriate strategy gets selected.
+ # However, this is necessary only if one of the piecewise
+ # functions depends on one of the symbols we are solving for.
+ def _has_piecewise(e):
+ if e.is_Piecewise:
+ return e.has(*symbols)
+ return any(_has_piecewise(a) for a in e.args)
+ for i, fi in enumerate(f):
+ if _has_piecewise(fi):
+ f[i] = piecewise_fold(fi)
+
+ #
+ # try to get a solution
+ ###########################################################################
+ if bare_f:
+ solution = None
+ if len(symbols) != 1:
+ solution = _solve_undetermined(f[0], symbols, flags)
+ if not solution:
+ solution = _solve(f[0], *symbols, **flags)
+ else:
+ linear, solution = _solve_system(f, symbols, **flags)
+ assert type(solution) is list
+ assert not solution or type(solution[0]) is dict, solution
+ #
+ # postprocessing
+ ###########################################################################
+ # capture as_dict flag now (as_set already captured)
+ as_dict = flags.get('dict', False)
+
+ # define how solution will get unpacked
+ tuple_format = lambda s: [tuple([i.get(x, x) for x in symbols]) for i in s]
+ if as_dict or as_set:
+ unpack = None
+ elif bare_f:
+ if len(symbols) == 1:
+ unpack = lambda s: [i[symbols[0]] for i in s]
+ elif len(solution) == 1 and len(solution[0]) == len(symbols):
+ # undetermined linear coeffs solution
+ unpack = lambda s: s[0]
+ elif ordered_symbols:
+ unpack = tuple_format
+ else:
+ unpack = lambda s: s
+ else:
+ if solution:
+ if linear and len(solution) == 1:
+ # if you want the tuple solution for the linear
+ # case, use `set=True`
+ unpack = lambda s: s[0]
+ elif ordered_symbols:
+ unpack = tuple_format
+ else:
+ unpack = lambda s: s
+ else:
+ unpack = None
+
+ # Restore masked-off objects
+ if non_inverts and type(solution) is list:
+ solution = [{k: v.subs(non_inverts) for k, v in s.items()}
+ for s in solution]
+
+ # Restore original "symbols" if a dictionary is returned.
+ # This is not necessary for
+ # - the single univariate equation case
+ # since the symbol will have been removed from the solution;
+ # - the nonlinear poly_system since that only supports zero-dimensional
+ # systems and those results come back as a list
+ #
+ # ** unless there were Derivatives with the symbols, but those were handled
+ # above.
+ if swap_sym:
+ symbols = [swap_sym.get(k, k) for k in symbols]
+ for i, sol in enumerate(solution):
+ solution[i] = {swap_sym.get(k, k): v.subs(swap_sym)
+ for k, v in sol.items()}
+
+ # Get assumptions about symbols, to filter solutions.
+ # Note that if assumptions about a solution can't be verified, it is still
+ # returned.
+ check = flags.get('check', True)
+
+ # restore floats
+ if floats and solution and flags.get('rational', None) is None:
+ solution = nfloat(solution, exponent=False)
+ # nfloat might reveal more duplicates
+ solution = _remove_duplicate_solutions(solution)
+
+ if check and solution: # assumption checking
+ warn = flags.get('warn', False)
+ got_None = [] # solutions for which one or more symbols gave None
+ no_False = [] # solutions for which no symbols gave False
+ for sol in solution:
+ a_None = False
+ for symb, val in sol.items():
+ test = check_assumptions(val, **symb.assumptions0)
+ if test:
+ continue
+ if test is False:
+ break
+ a_None = True
+ else:
+ no_False.append(sol)
+ if a_None:
+ got_None.append(sol)
+
+ solution = no_False
+ if warn and got_None:
+ warnings.warn(filldedent("""
+ \tWarning: assumptions concerning following solution(s)
+ cannot be checked:""" + '\n\t' +
+ ', '.join(str(s) for s in got_None)))
+
+ #
+ # done
+ ###########################################################################
+
+ if not solution:
+ if as_set:
+ return symbols, set()
+ return []
+
+ # make orderings canonical for list of dictionaries
+ if not as_set: # for set, no point in ordering
+ solution = [{k: s[k] for k in ordered(s)} for s in solution]
+ solution.sort(key=default_sort_key)
+
+ if not (as_set or as_dict):
+ return unpack(solution)
+
+ if as_dict:
+ return solution
+
+ # set output: (symbols, {t1, t2, ...}) from list of dictionaries;
+ # include all symbols for those that like a verbose solution
+ # and to resolve any differences in dictionary keys.
+ #
+ # The set results can easily be used to make a verbose dict as
+ # k, v = solve(eqs, syms, set=True)
+ # sol = [dict(zip(k,i)) for i in v]
+ #
+ if ordered_symbols:
+ k = symbols # keep preferred order
+ else:
+ # just unify the symbols for which solutions were found
+ k = list(ordered(set(flatten(tuple(i.keys()) for i in solution))))
+ return k, {tuple([s.get(ki, ki) for ki in k]) for s in solution}
+
+
+def _solve_undetermined(g, symbols, flags):
+ """solve helper to return a list with one dict (solution) else None
+
+ A direct call to solve_undetermined_coeffs is more flexible and
+ can return both multiple solutions and handle more than one independent
+ variable. Here, we have to be more cautious to keep from solving
+ something that does not look like an undetermined coeffs system --
+ to minimize the surprise factor since singularities that cancel are not
+ prohibited in solve_undetermined_coeffs.
+ """
+ if g.free_symbols - set(symbols):
+ sol = solve_undetermined_coeffs(g, symbols, **dict(flags, dict=True, set=None))
+ if len(sol) == 1:
+ return sol
+
+
+def _solve(f, *symbols, **flags):
+ """Return a checked solution for *f* in terms of one or more of the
+ symbols in the form of a list of dictionaries.
+
+ If no method is implemented to solve the equation, a NotImplementedError
+ will be raised. In the case that conversion of an expression to a Poly
+ gives None a ValueError will be raised.
+ """
+
+ not_impl_msg = "No algorithms are implemented to solve equation %s"
+
+ if len(symbols) != 1:
+ # look for solutions for desired symbols that are independent
+ # of symbols already solved for, e.g. if we solve for x = y
+ # then no symbol having x in its solution will be returned.
+
+ # First solve for linear symbols (since that is easier and limits
+ # solution size) and then proceed with symbols appearing
+ # in a non-linear fashion. Ideally, if one is solving a single
+ # expression for several symbols, they would have to be
+ # appear in factors of an expression, but we do not here
+ # attempt factorization. XXX perhaps handling a Mul
+ # should come first in this routine whether there is
+ # one or several symbols.
+ nonlin_s = []
+ got_s = set()
+ rhs_s = set()
+ result = []
+ for s in symbols:
+ xi, v = solve_linear(f, symbols=[s])
+ if xi == s:
+ # no need to check but we should simplify if desired
+ if flags.get('simplify', True):
+ v = simplify(v)
+ vfree = v.free_symbols
+ if vfree & got_s:
+ # was linear, but has redundant relationship
+ # e.g. x - y = 0 has y == x is redundant for x == y
+ # so ignore
+ continue
+ rhs_s |= vfree
+ got_s.add(xi)
+ result.append({xi: v})
+ elif xi: # there might be a non-linear solution if xi is not 0
+ nonlin_s.append(s)
+ if not nonlin_s:
+ return result
+ for s in nonlin_s:
+ try:
+ soln = _solve(f, s, **flags)
+ for sol in soln:
+ if sol[s].free_symbols & got_s:
+ # depends on previously solved symbols: ignore
+ continue
+ got_s.add(s)
+ result.append(sol)
+ except NotImplementedError:
+ continue
+ if got_s:
+ return result
+ else:
+ raise NotImplementedError(not_impl_msg % f)
+
+ # solve f for a single variable
+
+ symbol = symbols[0]
+
+ # expand binomials only if it has the unknown symbol
+ f = f.replace(lambda e: isinstance(e, binomial) and e.has(symbol),
+ lambda e: expand_func(e))
+
+ # checking will be done unless it is turned off before making a
+ # recursive call; the variables `checkdens` and `check` are
+ # captured here (for reference below) in case flag value changes
+ flags['check'] = checkdens = check = flags.pop('check', True)
+
+ # build up solutions if f is a Mul
+ if f.is_Mul:
+ result = set()
+ for m in f.args:
+ if m in {S.NegativeInfinity, S.ComplexInfinity, S.Infinity}:
+ result = set()
+ break
+ soln = _vsolve(m, symbol, **flags)
+ result.update(set(soln))
+ result = [{symbol: v} for v in result]
+ if check:
+ # all solutions have been checked but now we must
+ # check that the solutions do not set denominators
+ # in any factor to zero
+ dens = flags.get('_denominators', _simple_dens(f, symbols))
+ result = [s for s in result if
+ not any(checksol(den, s, **flags) for den in
+ dens)]
+ # set flags for quick exit at end; solutions for each
+ # factor were already checked and simplified
+ check = False
+ flags['simplify'] = False
+
+ elif f.is_Piecewise:
+ result = set()
+ for i, (expr, cond) in enumerate(f.args):
+ if expr.is_zero:
+ raise NotImplementedError(
+ 'solve cannot represent interval solutions')
+ candidates = _vsolve(expr, symbol, **flags)
+ # the explicit condition for this expr is the current cond
+ # and none of the previous conditions
+ args = [~c for _, c in f.args[:i]] + [cond]
+ cond = And(*args)
+ for candidate in candidates:
+ if candidate in result:
+ # an unconditional value was already there
+ continue
+ try:
+ v = cond.subs(symbol, candidate)
+ _eval_simplify = getattr(v, '_eval_simplify', None)
+ if _eval_simplify is not None:
+ # unconditionally take the simplification of v
+ v = _eval_simplify(ratio=2, measure=lambda x: 1)
+ except TypeError:
+ # incompatible type with condition(s)
+ continue
+ if v == False:
+ continue
+ if v == True:
+ result.add(candidate)
+ else:
+ result.add(Piecewise(
+ (candidate, v),
+ (S.NaN, True)))
+ # solutions already checked and simplified
+ # ****************************************
+ return [{symbol: r} for r in result]
+ else:
+ # first see if it really depends on symbol and whether there
+ # is only a linear solution
+ f_num, sol = solve_linear(f, symbols=symbols)
+ if f_num.is_zero or sol is S.NaN:
+ return []
+ elif f_num.is_Symbol:
+ # no need to check but simplify if desired
+ if flags.get('simplify', True):
+ sol = simplify(sol)
+ return [{f_num: sol}]
+
+ poly = None
+ # check for a single Add generator
+ if not f_num.is_Add:
+ add_args = [i for i in f_num.atoms(Add)
+ if symbol in i.free_symbols]
+ if len(add_args) == 1:
+ gen = add_args[0]
+ spart = gen.as_independent(symbol)[1].as_base_exp()[0]
+ if spart == symbol:
+ try:
+ poly = Poly(f_num, spart)
+ except PolynomialError:
+ pass
+
+ result = False # no solution was obtained
+ msg = '' # there is no failure message
+
+ # Poly is generally robust enough to convert anything to
+ # a polynomial and tell us the different generators that it
+ # contains, so we will inspect the generators identified by
+ # polys to figure out what to do.
+
+ # try to identify a single generator that will allow us to solve this
+ # as a polynomial, followed (perhaps) by a change of variables if the
+ # generator is not a symbol
+
+ try:
+ if poly is None:
+ poly = Poly(f_num)
+ if poly is None:
+ raise ValueError('could not convert %s to Poly' % f_num)
+ except GeneratorsNeeded:
+ simplified_f = simplify(f_num)
+ if simplified_f != f_num:
+ return _solve(simplified_f, symbol, **flags)
+ raise ValueError('expression appears to be a constant')
+
+ gens = [g for g in poly.gens if g.has(symbol)]
+
+ def _as_base_q(x):
+ """Return (b**e, q) for x = b**(p*e/q) where p/q is the leading
+ Rational of the exponent of x, e.g. exp(-2*x/3) -> (exp(x), 3)
+ """
+ b, e = x.as_base_exp()
+ if e.is_Rational:
+ return b, e.q
+ if not e.is_Mul:
+ return x, 1
+ c, ee = e.as_coeff_Mul()
+ if c.is_Rational and c is not S.One: # c could be a Float
+ return b**ee, c.q
+ return x, 1
+
+ if len(gens) > 1:
+ # If there is more than one generator, it could be that the
+ # generators have the same base but different powers, e.g.
+ # >>> Poly(exp(x) + 1/exp(x))
+ # Poly(exp(-x) + exp(x), exp(-x), exp(x), domain='ZZ')
+ #
+ # If unrad was not disabled then there should be no rational
+ # exponents appearing as in
+ # >>> Poly(sqrt(x) + sqrt(sqrt(x)))
+ # Poly(sqrt(x) + x**(1/4), sqrt(x), x**(1/4), domain='ZZ')
+
+ bases, qs = list(zip(*[_as_base_q(g) for g in gens]))
+ bases = set(bases)
+
+ if len(bases) > 1 or not all(q == 1 for q in qs):
+ funcs = {b for b in bases if b.is_Function}
+
+ trig = {_ for _ in funcs if
+ isinstance(_, TrigonometricFunction)}
+ other = funcs - trig
+ if not other and len(funcs.intersection(trig)) > 1:
+ newf = None
+ if f_num.is_Add and len(f_num.args) == 2:
+ # check for sin(x)**p = cos(x)**p
+ _args = f_num.args
+ t = a, b = [i.atoms(Function).intersection(
+ trig) for i in _args]
+ if all(len(i) == 1 for i in t):
+ a, b = [i.pop() for i in t]
+ if isinstance(a, cos):
+ a, b = b, a
+ _args = _args[::-1]
+ if isinstance(a, sin) and isinstance(b, cos
+ ) and a.args[0] == b.args[0]:
+ # sin(x) + cos(x) = 0 -> tan(x) + 1 = 0
+ newf, _d = (TR2i(_args[0]/_args[1]) + 1
+ ).as_numer_denom()
+ if not _d.is_Number:
+ newf = None
+ if newf is None:
+ newf = TR1(f_num).rewrite(tan)
+ if newf != f_num:
+ # don't check the rewritten form --check
+ # solutions in the un-rewritten form below
+ flags['check'] = False
+ result = _solve(newf, symbol, **flags)
+ flags['check'] = check
+
+ # just a simple case - see if replacement of single function
+ # clears all symbol-dependent functions, e.g.
+ # log(x) - log(log(x) - 1) - 3 can be solved even though it has
+ # two generators.
+
+ if result is False and funcs:
+ funcs = list(ordered(funcs)) # put shallowest function first
+ f1 = funcs[0]
+ t = Dummy('t')
+ # perform the substitution
+ ftry = f_num.subs(f1, t)
+
+ # if no Functions left, we can proceed with usual solve
+ if not ftry.has(symbol):
+ cv_sols = _solve(ftry, t, **flags)
+ cv_inv = list(ordered(_vsolve(t - f1, symbol, **flags)))[0]
+ result = [{symbol: cv_inv.subs(sol)} for sol in cv_sols]
+
+ if result is False:
+ msg = 'multiple generators %s' % gens
+
+ else:
+ # e.g. case where gens are exp(x), exp(-x)
+ u = bases.pop()
+ t = Dummy('t')
+ inv = _vsolve(u - t, symbol, **flags)
+ if isinstance(u, (Pow, exp)):
+ # this will be resolved by factor in _tsolve but we might
+ # as well try a simple expansion here to get things in
+ # order so something like the following will work now without
+ # having to factor:
+ #
+ # >>> eq = (exp(I*(-x-2))+exp(I*(x+2)))
+ # >>> eq.subs(exp(x),y) # fails
+ # exp(I*(-x - 2)) + exp(I*(x + 2))
+ # >>> eq.expand().subs(exp(x),y) # works
+ # y**I*exp(2*I) + y**(-I)*exp(-2*I)
+ def _expand(p):
+ b, e = p.as_base_exp()
+ e = expand_mul(e)
+ return expand_power_exp(b**e)
+ ftry = f_num.replace(
+ lambda w: w.is_Pow or isinstance(w, exp),
+ _expand).subs(u, t)
+ if not ftry.has(symbol):
+ soln = _solve(ftry, t, **flags)
+ result = [{symbol: i.subs(s)} for i in inv for s in soln]
+
+ elif len(gens) == 1:
+
+ # There is only one generator that we are interested in, but
+ # there may have been more than one generator identified by
+ # polys (e.g. for symbols other than the one we are interested
+ # in) so recast the poly in terms of our generator of interest.
+ # Also use composite=True with f_num since Poly won't update
+ # poly as documented in issue 8810.
+
+ poly = Poly(f_num, gens[0], composite=True)
+
+ # if we aren't on the tsolve-pass, use roots
+ if not flags.pop('tsolve', False):
+ soln = None
+ deg = poly.degree()
+ flags['tsolve'] = True
+ hints = ('cubics', 'quartics', 'quintics')
+ solvers = {h: flags.get(h) for h in hints}
+ soln = roots(poly, **solvers)
+ if sum(soln.values()) < deg:
+ # e.g. roots(32*x**5 + 400*x**4 + 2032*x**3 +
+ # 5000*x**2 + 6250*x + 3189) -> {}
+ # so all_roots is used and RootOf instances are
+ # returned *unless* the system is multivariate
+ # or high-order EX domain.
+ try:
+ soln = poly.all_roots()
+ except NotImplementedError:
+ if not flags.get('incomplete', True):
+ raise NotImplementedError(
+ filldedent('''
+ Neither high-order multivariate polynomials
+ nor sorting of EX-domain polynomials is supported.
+ If you want to see any results, pass keyword incomplete=True to
+ solve; to see numerical values of roots
+ for univariate expressions, use nroots.
+ '''))
+ else:
+ pass
+ else:
+ soln = list(soln.keys())
+
+ if soln is not None:
+ u = poly.gen
+ if u != symbol:
+ try:
+ t = Dummy('t')
+ inv = _vsolve(u - t, symbol, **flags)
+ soln = {i.subs(t, s) for i in inv for s in soln}
+ except NotImplementedError:
+ # perhaps _tsolve can handle f_num
+ soln = None
+ else:
+ check = False # only dens need to be checked
+ if soln is not None:
+ if len(soln) > 2:
+ # if the flag wasn't set then unset it since high-order
+ # results are quite long. Perhaps one could base this
+ # decision on a certain critical length of the
+ # roots. In addition, wester test M2 has an expression
+ # whose roots can be shown to be real with the
+ # unsimplified form of the solution whereas only one of
+ # the simplified forms appears to be real.
+ flags['simplify'] = flags.get('simplify', False)
+ if soln is not None:
+ result = [{symbol: v} for v in soln]
+
+ # fallback if above fails
+ # -----------------------
+ if result is False:
+ # try unrad
+ if flags.pop('_unrad', True):
+ try:
+ u = unrad(f_num, symbol)
+ except (ValueError, NotImplementedError):
+ u = False
+ if u:
+ eq, cov = u
+ if cov:
+ isym, ieq = cov
+ inv = _vsolve(ieq, symbol, **flags)[0]
+ rv = {inv.subs(xi) for xi in _solve(eq, isym, **flags)}
+ else:
+ try:
+ rv = set(_vsolve(eq, symbol, **flags))
+ except NotImplementedError:
+ rv = None
+ if rv is not None:
+ result = [{symbol: v} for v in rv]
+ # if the flag wasn't set then unset it since unrad results
+ # can be quite long or of very high order
+ flags['simplify'] = flags.get('simplify', False)
+ else:
+ pass # for coverage
+
+ # try _tsolve
+ if result is False:
+ flags.pop('tsolve', None) # allow tsolve to be used on next pass
+ try:
+ soln = _tsolve(f_num, symbol, **flags)
+ if soln is not None:
+ result = [{symbol: v} for v in soln]
+ except PolynomialError:
+ pass
+ # ----------- end of fallback ----------------------------
+
+ if result is False:
+ raise NotImplementedError('\n'.join([msg, not_impl_msg % f]))
+
+ result = _remove_duplicate_solutions(result)
+
+ if flags.get('simplify', True):
+ result = [{k: d[k].simplify() for k in d} for d in result]
+ # Simplification might reveal more duplicates
+ result = _remove_duplicate_solutions(result)
+ # we just simplified the solution so we now set the flag to
+ # False so the simplification doesn't happen again in checksol()
+ flags['simplify'] = False
+
+ if checkdens:
+ # reject any result that makes any denom. affirmatively 0;
+ # if in doubt, keep it
+ dens = _simple_dens(f, symbols)
+ result = [r for r in result if
+ not any(checksol(d, r, **flags)
+ for d in dens)]
+ if check:
+ # keep only results if the check is not False
+ result = [r for r in result if
+ checksol(f_num, r, **flags) is not False]
+ return result
+
+
+def _remove_duplicate_solutions(solutions: list[dict[Expr, Expr]]
+ ) -> list[dict[Expr, Expr]]:
+ """Remove duplicates from a list of dicts"""
+ solutions_set = set()
+ solutions_new = []
+
+ for sol in solutions:
+ solset = frozenset(sol.items())
+ if solset not in solutions_set:
+ solutions_new.append(sol)
+ solutions_set.add(solset)
+
+ return solutions_new
+
+
+def _solve_system(exprs, symbols, **flags):
+ """return ``(linear, solution)`` where ``linear`` is True
+ if the system was linear, else False; ``solution``
+ is a list of dictionaries giving solutions for the symbols
+ """
+ if not exprs:
+ return False, []
+
+ if flags.pop('_split', True):
+ # Split the system into connected components
+ V = exprs
+ symsset = set(symbols)
+ exprsyms = {e: e.free_symbols & symsset for e in exprs}
+ E = []
+ sym_indices = {sym: i for i, sym in enumerate(symbols)}
+ for n, e1 in enumerate(exprs):
+ for e2 in exprs[:n]:
+ # Equations are connected if they share a symbol
+ if exprsyms[e1] & exprsyms[e2]:
+ E.append((e1, e2))
+ G = V, E
+ subexprs = connected_components(G)
+ if len(subexprs) > 1:
+ subsols = []
+ linear = True
+ for subexpr in subexprs:
+ subsyms = set()
+ for e in subexpr:
+ subsyms |= exprsyms[e]
+ subsyms = sorted(subsyms, key = lambda x: sym_indices[x])
+ flags['_split'] = False # skip split step
+ _linear, subsol = _solve_system(subexpr, subsyms, **flags)
+ if linear:
+ linear = linear and _linear
+ if not isinstance(subsol, list):
+ subsol = [subsol]
+ subsols.append(subsol)
+ # Full solution is cartesion product of subsystems
+ sols = []
+ for soldicts in product(*subsols):
+ sols.append(dict(item for sd in soldicts
+ for item in sd.items()))
+ return linear, sols
+
+ polys = []
+ dens = set()
+ failed = []
+ result = []
+ solved_syms = []
+ linear = True
+ manual = flags.get('manual', False)
+ checkdens = check = flags.get('check', True)
+
+ for j, g in enumerate(exprs):
+ dens.update(_simple_dens(g, symbols))
+ i, d = _invert(g, *symbols)
+ if d in symbols:
+ if linear:
+ linear = solve_linear(g, 0, [d])[0] == d
+ g = d - i
+ g = g.as_numer_denom()[0]
+ if manual:
+ failed.append(g)
+ continue
+
+ poly = g.as_poly(*symbols, extension=True)
+
+ if poly is not None:
+ polys.append(poly)
+ else:
+ failed.append(g)
+
+ if polys:
+ if all(p.is_linear for p in polys):
+ n, m = len(polys), len(symbols)
+ matrix = zeros(n, m + 1)
+
+ for i, poly in enumerate(polys):
+ for monom, coeff in poly.terms():
+ try:
+ j = monom.index(1)
+ matrix[i, j] = coeff
+ except ValueError:
+ matrix[i, m] = -coeff
+
+ # returns a dictionary ({symbols: values}) or None
+ if flags.pop('particular', False):
+ result = minsolve_linear_system(matrix, *symbols, **flags)
+ else:
+ result = solve_linear_system(matrix, *symbols, **flags)
+ result = [result] if result else []
+ if failed:
+ if result:
+ solved_syms = list(result[0].keys()) # there is only one result dict
+ else:
+ solved_syms = []
+ # linear doesn't change
+ else:
+ linear = False
+ if len(symbols) > len(polys):
+
+ free = set().union(*[p.free_symbols for p in polys])
+ free = list(ordered(free.intersection(symbols)))
+ got_s = set()
+ result = []
+ for syms in subsets(free, len(polys)):
+ try:
+ # returns [], None or list of tuples
+ res = solve_poly_system(polys, *syms)
+ if res:
+ for r in set(res):
+ skip = False
+ for r1 in r:
+ if got_s and any(ss in r1.free_symbols
+ for ss in got_s):
+ # sol depends on previously
+ # solved symbols: discard it
+ skip = True
+ if not skip:
+ got_s.update(syms)
+ result.append(dict(list(zip(syms, r))))
+ except NotImplementedError:
+ pass
+ if got_s:
+ solved_syms = list(got_s)
+ else:
+ raise NotImplementedError('no valid subset found')
+ else:
+ try:
+ result = solve_poly_system(polys, *symbols)
+ if result:
+ solved_syms = symbols
+ result = [dict(list(zip(solved_syms, r))) for r in set(result)]
+ except NotImplementedError:
+ failed.extend([g.as_expr() for g in polys])
+ solved_syms = []
+
+ # convert None or [] to [{}]
+ result = result or [{}]
+
+ if failed:
+ linear = False
+ # For each failed equation, see if we can solve for one of the
+ # remaining symbols from that equation. If so, we update the
+ # solution set and continue with the next failed equation,
+ # repeating until we are done or we get an equation that can't
+ # be solved.
+ def _ok_syms(e, sort=False):
+ rv = e.free_symbols & legal
+
+ # Solve first for symbols that have lower degree in the equation.
+ # Ideally we want to solve firstly for symbols that appear linearly
+ # with rational coefficients e.g. if e = x*y + z then we should
+ # solve for z first.
+ def key(sym):
+ ep = e.as_poly(sym)
+ if ep is None:
+ complexity = (S.Infinity, S.Infinity, S.Infinity)
+ else:
+ coeff_syms = ep.LC().free_symbols
+ complexity = (ep.degree(), len(coeff_syms & rv), len(coeff_syms))
+ return complexity + (default_sort_key(sym),)
+
+ if sort:
+ rv = sorted(rv, key=key)
+ return rv
+
+ legal = set(symbols) # what we are interested in
+ # sort so equation with the fewest potential symbols is first
+ u = Dummy() # used in solution checking
+ for eq in ordered(failed, lambda _: len(_ok_syms(_))):
+ newresult = []
+ bad_results = []
+ hit = False
+ for r in result:
+ got_s = set()
+ # update eq with everything that is known so far
+ eq2 = eq.subs(r)
+ # if check is True then we see if it satisfies this
+ # equation, otherwise we just accept it
+ if check and r:
+ b = checksol(u, u, eq2, minimal=True)
+ if b is not None:
+ # this solution is sufficient to know whether
+ # it is valid or not so we either accept or
+ # reject it, then continue
+ if b:
+ newresult.append(r)
+ else:
+ bad_results.append(r)
+ continue
+ # search for a symbol amongst those available that
+ # can be solved for
+ ok_syms = _ok_syms(eq2, sort=True)
+ if not ok_syms:
+ if r:
+ newresult.append(r)
+ break # skip as it's independent of desired symbols
+ for s in ok_syms:
+ try:
+ soln = _vsolve(eq2, s, **flags)
+ except NotImplementedError:
+ continue
+ # put each solution in r and append the now-expanded
+ # result in the new result list; use copy since the
+ # solution for s is being added in-place
+ for sol in soln:
+ if got_s and any(ss in sol.free_symbols for ss in got_s):
+ # sol depends on previously solved symbols: discard it
+ continue
+ rnew = r.copy()
+ for k, v in r.items():
+ rnew[k] = v.subs(s, sol)
+ # and add this new solution
+ rnew[s] = sol
+ # check that it is independent of previous solutions
+ iset = set(rnew.items())
+ for i in newresult:
+ if len(i) < len(iset) and not set(i.items()) - iset:
+ # this is a superset of a known solution that
+ # is smaller
+ break
+ else:
+ # keep it
+ newresult.append(rnew)
+ hit = True
+ got_s.add(s)
+ if not hit:
+ raise NotImplementedError('could not solve %s' % eq2)
+ else:
+ result = newresult
+ for b in bad_results:
+ if b in result:
+ result.remove(b)
+
+ if not result:
+ return False, []
+
+ # rely on linear/polynomial system solvers to simplify
+ # XXX the following tests show that the expressions
+ # returned are not the same as they would be if simplify
+ # were applied to this:
+ # sympy/solvers/ode/tests/test_systems/test__classify_linear_system
+ # sympy/solvers/tests/test_solvers/test_issue_4886
+ # so the docs should be updated to reflect that or else
+ # the following should be `bool(failed) or not linear`
+ default_simplify = bool(failed)
+ if flags.get('simplify', default_simplify):
+ for r in result:
+ for k in r:
+ r[k] = simplify(r[k])
+ flags['simplify'] = False # don't need to do so in checksol now
+
+ if checkdens:
+ result = [r for r in result
+ if not any(checksol(d, r, **flags) for d in dens)]
+
+ if check and not linear:
+ result = [r for r in result
+ if not any(checksol(e, r, **flags) is False for e in exprs)]
+
+ result = [r for r in result if r]
+ return linear, result
+
+
+def solve_linear(lhs, rhs=0, symbols=[], exclude=[]):
+ r"""
+ Return a tuple derived from ``f = lhs - rhs`` that is one of
+ the following: ``(0, 1)``, ``(0, 0)``, ``(symbol, solution)``, ``(n, d)``.
+
+ Explanation
+ ===========
+
+ ``(0, 1)`` meaning that ``f`` is independent of the symbols in *symbols*
+ that are not in *exclude*.
+
+ ``(0, 0)`` meaning that there is no solution to the equation amongst the
+ symbols given. If the first element of the tuple is not zero, then the
+ function is guaranteed to be dependent on a symbol in *symbols*.
+
+ ``(symbol, solution)`` where symbol appears linearly in the numerator of
+ ``f``, is in *symbols* (if given), and is not in *exclude* (if given). No
+ simplification is done to ``f`` other than a ``mul=True`` expansion, so the
+ solution will correspond strictly to a unique solution.
+
+ ``(n, d)`` where ``n`` and ``d`` are the numerator and denominator of ``f``
+ when the numerator was not linear in any symbol of interest; ``n`` will
+ never be a symbol unless a solution for that symbol was found (in which case
+ the second element is the solution, not the denominator).
+
+ Examples
+ ========
+
+ >>> from sympy import cancel, Pow
+
+ ``f`` is independent of the symbols in *symbols* that are not in
+ *exclude*:
+
+ >>> from sympy import cos, sin, solve_linear
+ >>> from sympy.abc import x, y, z
+ >>> eq = y*cos(x)**2 + y*sin(x)**2 - y # = y*(1 - 1) = 0
+ >>> solve_linear(eq)
+ (0, 1)
+ >>> eq = cos(x)**2 + sin(x)**2 # = 1
+ >>> solve_linear(eq)
+ (0, 1)
+ >>> solve_linear(x, exclude=[x])
+ (0, 1)
+
+ The variable ``x`` appears as a linear variable in each of the
+ following:
+
+ >>> solve_linear(x + y**2)
+ (x, -y**2)
+ >>> solve_linear(1/x - y**2)
+ (x, y**(-2))
+
+ When not linear in ``x`` or ``y`` then the numerator and denominator are
+ returned:
+
+ >>> solve_linear(x**2/y**2 - 3)
+ (x**2 - 3*y**2, y**2)
+
+ If the numerator of the expression is a symbol, then ``(0, 0)`` is
+ returned if the solution for that symbol would have set any
+ denominator to 0:
+
+ >>> eq = 1/(1/x - 2)
+ >>> eq.as_numer_denom()
+ (x, 1 - 2*x)
+ >>> solve_linear(eq)
+ (0, 0)
+
+ But automatic rewriting may cause a symbol in the denominator to
+ appear in the numerator so a solution will be returned:
+
+ >>> (1/x)**-1
+ x
+ >>> solve_linear((1/x)**-1)
+ (x, 0)
+
+ Use an unevaluated expression to avoid this:
+
+ >>> solve_linear(Pow(1/x, -1, evaluate=False))
+ (0, 0)
+
+ If ``x`` is allowed to cancel in the following expression, then it
+ appears to be linear in ``x``, but this sort of cancellation is not
+ done by ``solve_linear`` so the solution will always satisfy the
+ original expression without causing a division by zero error.
+
+ >>> eq = x**2*(1/x - z**2/x)
+ >>> solve_linear(cancel(eq))
+ (x, 0)
+ >>> solve_linear(eq)
+ (x**2*(1 - z**2), x)
+
+ A list of symbols for which a solution is desired may be given:
+
+ >>> solve_linear(x + y + z, symbols=[y])
+ (y, -x - z)
+
+ A list of symbols to ignore may also be given:
+
+ >>> solve_linear(x + y + z, exclude=[x])
+ (y, -x - z)
+
+ (A solution for ``y`` is obtained because it is the first variable
+ from the canonically sorted list of symbols that had a linear
+ solution.)
+
+ """
+ if isinstance(lhs, Eq):
+ if rhs:
+ raise ValueError(filldedent('''
+ If lhs is an Equality, rhs must be 0 but was %s''' % rhs))
+ rhs = lhs.rhs
+ lhs = lhs.lhs
+ dens = None
+ eq = lhs - rhs
+ n, d = eq.as_numer_denom()
+ if not n:
+ return S.Zero, S.One
+
+ free = n.free_symbols
+ if not symbols:
+ symbols = free
+ else:
+ bad = [s for s in symbols if not s.is_Symbol]
+ if bad:
+ if len(bad) == 1:
+ bad = bad[0]
+ if len(symbols) == 1:
+ eg = 'solve(%s, %s)' % (eq, symbols[0])
+ else:
+ eg = 'solve(%s, *%s)' % (eq, list(symbols))
+ raise ValueError(filldedent('''
+ solve_linear only handles symbols, not %s. To isolate
+ non-symbols use solve, e.g. >>> %s <<<.
+ ''' % (bad, eg)))
+ symbols = free.intersection(symbols)
+ symbols = symbols.difference(exclude)
+ if not symbols:
+ return S.Zero, S.One
+
+ # derivatives are easy to do but tricky to analyze to see if they
+ # are going to disallow a linear solution, so for simplicity we
+ # just evaluate the ones that have the symbols of interest
+ derivs = defaultdict(list)
+ for der in n.atoms(Derivative):
+ csym = der.free_symbols & symbols
+ for c in csym:
+ derivs[c].append(der)
+
+ all_zero = True
+ for xi in sorted(symbols, key=default_sort_key): # canonical order
+ # if there are derivatives in this var, calculate them now
+ if isinstance(derivs[xi], list):
+ derivs[xi] = {der: der.doit() for der in derivs[xi]}
+ newn = n.subs(derivs[xi])
+ dnewn_dxi = newn.diff(xi)
+ # dnewn_dxi can be nonzero if it survives differentation by any
+ # of its free symbols
+ free = dnewn_dxi.free_symbols
+ if dnewn_dxi and (not free or any(dnewn_dxi.diff(s) for s in free) or free == symbols):
+ all_zero = False
+ if dnewn_dxi is S.NaN:
+ break
+ if xi not in dnewn_dxi.free_symbols:
+ vi = -1/dnewn_dxi*(newn.subs(xi, 0))
+ if dens is None:
+ dens = _simple_dens(eq, symbols)
+ if not any(checksol(di, {xi: vi}, minimal=True) is True
+ for di in dens):
+ # simplify any trivial integral
+ irep = [(i, i.doit()) for i in vi.atoms(Integral) if
+ i.function.is_number]
+ # do a slight bit of simplification
+ vi = expand_mul(vi.subs(irep))
+ return xi, vi
+ if all_zero:
+ return S.Zero, S.One
+ if n.is_Symbol: # no solution for this symbol was found
+ return S.Zero, S.Zero
+ return n, d
+
+
+def minsolve_linear_system(system, *symbols, **flags):
+ r"""
+ Find a particular solution to a linear system.
+
+ Explanation
+ ===========
+
+ In particular, try to find a solution with the minimal possible number
+ of non-zero variables using a naive algorithm with exponential complexity.
+ If ``quick=True``, a heuristic is used.
+
+ """
+ quick = flags.get('quick', False)
+ # Check if there are any non-zero solutions at all
+ s0 = solve_linear_system(system, *symbols, **flags)
+ if not s0 or all(v == 0 for v in s0.values()):
+ return s0
+ if quick:
+ # We just solve the system and try to heuristically find a nice
+ # solution.
+ s = solve_linear_system(system, *symbols)
+ def update(determined, solution):
+ delete = []
+ for k, v in solution.items():
+ solution[k] = v.subs(determined)
+ if not solution[k].free_symbols:
+ delete.append(k)
+ determined[k] = solution[k]
+ for k in delete:
+ del solution[k]
+ determined = {}
+ update(determined, s)
+ while s:
+ # NOTE sort by default_sort_key to get deterministic result
+ k = max((k for k in s.values()),
+ key=lambda x: (len(x.free_symbols), default_sort_key(x)))
+ kfree = k.free_symbols
+ x = next(reversed(list(ordered(kfree))))
+ if len(kfree) != 1:
+ determined[x] = S.Zero
+ else:
+ val = _vsolve(k, x, check=False)[0]
+ if not val and not any(v.subs(x, val) for v in s.values()):
+ determined[x] = S.One
+ else:
+ determined[x] = val
+ update(determined, s)
+ return determined
+ else:
+ # We try to select n variables which we want to be non-zero.
+ # All others will be assumed zero. We try to solve the modified system.
+ # If there is a non-trivial solution, just set the free variables to
+ # one. If we do this for increasing n, trying all combinations of
+ # variables, we will find an optimal solution.
+ # We speed up slightly by starting at one less than the number of
+ # variables the quick method manages.
+ N = len(symbols)
+ bestsol = minsolve_linear_system(system, *symbols, quick=True)
+ n0 = len([x for x in bestsol.values() if x != 0])
+ for n in range(n0 - 1, 1, -1):
+ debugf('minsolve: %s', n)
+ thissol = None
+ for nonzeros in combinations(range(N), n):
+ subm = Matrix([system.col(i).T for i in nonzeros] + [system.col(-1).T]).T
+ s = solve_linear_system(subm, *[symbols[i] for i in nonzeros])
+ if s and not all(v == 0 for v in s.values()):
+ subs = [(symbols[v], S.One) for v in nonzeros]
+ for k, v in s.items():
+ s[k] = v.subs(subs)
+ for sym in symbols:
+ if sym not in s:
+ if symbols.index(sym) in nonzeros:
+ s[sym] = S.One
+ else:
+ s[sym] = S.Zero
+ thissol = s
+ break
+ if thissol is None:
+ break
+ bestsol = thissol
+ return bestsol
+
+
+def solve_linear_system(system, *symbols, **flags):
+ r"""
+ Solve system of $N$ linear equations with $M$ variables, which means
+ both under- and overdetermined systems are supported.
+
+ Explanation
+ ===========
+
+ The possible number of solutions is zero, one, or infinite. Respectively,
+ this procedure will return None or a dictionary with solutions. In the
+ case of underdetermined systems, all arbitrary parameters are skipped.
+ This may cause a situation in which an empty dictionary is returned.
+ In that case, all symbols can be assigned arbitrary values.
+
+ Input to this function is a $N\times M + 1$ matrix, which means it has
+ to be in augmented form. If you prefer to enter $N$ equations and $M$
+ unknowns then use ``solve(Neqs, *Msymbols)`` instead. Note: a local
+ copy of the matrix is made by this routine so the matrix that is
+ passed will not be modified.
+
+ The algorithm used here is fraction-free Gaussian elimination,
+ which results, after elimination, in an upper-triangular matrix.
+ Then solutions are found using back-substitution. This approach
+ is more efficient and compact than the Gauss-Jordan method.
+
+ Examples
+ ========
+
+ >>> from sympy import Matrix, solve_linear_system
+ >>> from sympy.abc import x, y
+
+ Solve the following system::
+
+ x + 4 y == 2
+ -2 x + y == 14
+
+ >>> system = Matrix(( (1, 4, 2), (-2, 1, 14)))
+ >>> solve_linear_system(system, x, y)
+ {x: -6, y: 2}
+
+ A degenerate system returns an empty dictionary:
+
+ >>> system = Matrix(( (0,0,0), (0,0,0) ))
+ >>> solve_linear_system(system, x, y)
+ {}
+
+ """
+ assert system.shape[1] == len(symbols) + 1
+
+ # This is just a wrapper for solve_lin_sys
+ eqs = list(system * Matrix(symbols + (-1,)))
+ eqs, ring = sympy_eqs_to_ring(eqs, symbols)
+ sol = solve_lin_sys(eqs, ring, _raw=False)
+ if sol is not None:
+ sol = {sym:val for sym, val in sol.items() if sym != val}
+ return sol
+
+
+def solve_undetermined_coeffs(equ, coeffs, *syms, **flags):
+ r"""
+ Solve a system of equations in $k$ parameters that is formed by
+ matching coefficients in variables ``coeffs`` that are on
+ factors dependent on the remaining variables (or those given
+ explicitly by ``syms``.
+
+ Explanation
+ ===========
+
+ The result of this function is a dictionary with symbolic values of those
+ parameters with respect to coefficients in $q$ -- empty if there
+ is no solution or coefficients do not appear in the equation -- else
+ None (if the system was not recognized). If there is more than one
+ solution, the solutions are passed as a list. The output can be modified using
+ the same semantics as for `solve` since the flags that are passed are sent
+ directly to `solve` so, for example the flag ``dict=True`` will always return a list
+ of solutions as dictionaries.
+
+ This function accepts both Equality and Expr class instances.
+ The solving process is most efficient when symbols are specified
+ in addition to parameters to be determined, but an attempt to
+ determine them (if absent) will be made. If an expected solution is not
+ obtained (and symbols were not specified) try specifying them.
+
+ Examples
+ ========
+
+ >>> from sympy import Eq, solve_undetermined_coeffs
+ >>> from sympy.abc import a, b, c, h, p, k, x, y
+
+ >>> solve_undetermined_coeffs(Eq(a*x + a + b, x/2), [a, b], x)
+ {a: 1/2, b: -1/2}
+ >>> solve_undetermined_coeffs(a - 2, [a])
+ {a: 2}
+
+ The equation can be nonlinear in the symbols:
+
+ >>> X, Y, Z = y, x**y, y*x**y
+ >>> eq = a*X + b*Y + c*Z - X - 2*Y - 3*Z
+ >>> coeffs = a, b, c
+ >>> syms = x, y
+ >>> solve_undetermined_coeffs(eq, coeffs, syms)
+ {a: 1, b: 2, c: 3}
+
+ And the system can be nonlinear in coefficients, too, but if
+ there is only a single solution, it will be returned as a
+ dictionary:
+
+ >>> eq = a*x**2 + b*x + c - ((x - h)**2 + 4*p*k)/4/p
+ >>> solve_undetermined_coeffs(eq, (h, p, k), x)
+ {h: -b/(2*a), k: (4*a*c - b**2)/(4*a), p: 1/(4*a)}
+
+ Multiple solutions are always returned in a list:
+
+ >>> solve_undetermined_coeffs(a**2*x + b - x, [a, b], x)
+ [{a: -1, b: 0}, {a: 1, b: 0}]
+
+ Using flag ``dict=True`` (in keeping with semantics in :func:`~.solve`)
+ will force the result to always be a list with any solutions
+ as elements in that list.
+
+ >>> solve_undetermined_coeffs(a*x - 2*x, [a], dict=True)
+ [{a: 2}]
+ """
+ if not (coeffs and all(i.is_Symbol for i in coeffs)):
+ raise ValueError('must provide symbols for coeffs')
+
+ if isinstance(equ, Eq):
+ eq = equ.lhs - equ.rhs
+ else:
+ eq = equ
+
+ ceq = cancel(eq)
+ xeq = _mexpand(ceq.as_numer_denom()[0], recursive=True)
+
+ free = xeq.free_symbols
+ coeffs = free & set(coeffs)
+ if not coeffs:
+ return ([], {}) if flags.get('set', None) else [] # solve(0, x) -> []
+
+ if not syms:
+ # e.g. A*exp(x) + B - (exp(x) + y) separated into parts that
+ # don't/do depend on coeffs gives
+ # -(exp(x) + y), A*exp(x) + B
+ # then see what symbols are common to both
+ # {x} = {x, A, B} - {x, y}
+ ind, dep = xeq.as_independent(*coeffs, as_Add=True)
+ dfree = dep.free_symbols
+ syms = dfree & ind.free_symbols
+ if not syms:
+ # but if the system looks like (a + b)*x + b - c
+ # then {} = {a, b, x} - c
+ # so calculate {x} = {a, b, x} - {a, b}
+ syms = dfree - set(coeffs)
+ if not syms:
+ syms = [Dummy()]
+ else:
+ if len(syms) == 1 and iterable(syms[0]):
+ syms = syms[0]
+ e, s, _ = recast_to_symbols([xeq], syms)
+ xeq = e[0]
+ syms = s
+
+ # find the functional forms in which symbols appear
+
+ gens = set(xeq.as_coefficients_dict(*syms).keys()) - {1}
+ cset = set(coeffs)
+ if any(g.has_xfree(cset) for g in gens):
+ return # a generator contained a coefficient symbol
+
+ # make sure we are working with symbols for generators
+
+ e, gens, _ = recast_to_symbols([xeq], list(gens))
+ xeq = e[0]
+
+ # collect coefficients in front of generators
+
+ system = list(collect(xeq, gens, evaluate=False).values())
+
+ # get a solution
+
+ soln = solve(system, coeffs, **flags)
+
+ # unpack unless told otherwise if length is 1
+
+ settings = flags.get('dict', None) or flags.get('set', None)
+ if type(soln) is dict or settings or len(soln) != 1:
+ return soln
+ return soln[0]
+
+
+def solve_linear_system_LU(matrix, syms):
+ """
+ Solves the augmented matrix system using ``LUsolve`` and returns a
+ dictionary in which solutions are keyed to the symbols of *syms* as ordered.
+
+ Explanation
+ ===========
+
+ The matrix must be invertible.
+
+ Examples
+ ========
+
+ >>> from sympy import Matrix, solve_linear_system_LU
+ >>> from sympy.abc import x, y, z
+
+ >>> solve_linear_system_LU(Matrix([
+ ... [1, 2, 0, 1],
+ ... [3, 2, 2, 1],
+ ... [2, 0, 0, 1]]), [x, y, z])
+ {x: 1/2, y: 1/4, z: -1/2}
+
+ See Also
+ ========
+
+ LUsolve
+
+ """
+ if matrix.rows != matrix.cols - 1:
+ raise ValueError("Rows should be equal to columns - 1")
+ A = matrix[:matrix.rows, :matrix.rows]
+ b = matrix[:, matrix.cols - 1:]
+ soln = A.LUsolve(b)
+ solutions = {}
+ for i in range(soln.rows):
+ solutions[syms[i]] = soln[i, 0]
+ return solutions
+
+
+def det_perm(M):
+ """
+ Return the determinant of *M* by using permutations to select factors.
+
+ Explanation
+ ===========
+
+ For sizes larger than 8 the number of permutations becomes prohibitively
+ large, or if there are no symbols in the matrix, it is better to use the
+ standard determinant routines (e.g., ``M.det()``.)
+
+ See Also
+ ========
+
+ det_minor
+ det_quick
+
+ """
+ args = []
+ s = True
+ n = M.rows
+ list_ = M.flat()
+ for perm in generate_bell(n):
+ fac = []
+ idx = 0
+ for j in perm:
+ fac.append(list_[idx + j])
+ idx += n
+ term = Mul(*fac) # disaster with unevaluated Mul -- takes forever for n=7
+ args.append(term if s else -term)
+ s = not s
+ return Add(*args)
+
+
+def det_minor(M):
+ """
+ Return the ``det(M)`` computed from minors without
+ introducing new nesting in products.
+
+ See Also
+ ========
+
+ det_perm
+ det_quick
+
+ """
+ n = M.rows
+ if n == 2:
+ return M[0, 0]*M[1, 1] - M[1, 0]*M[0, 1]
+ else:
+ return sum([(1, -1)[i % 2]*Add(*[M[0, i]*d for d in
+ Add.make_args(det_minor(M.minor_submatrix(0, i)))])
+ if M[0, i] else S.Zero for i in range(n)])
+
+
+def det_quick(M, method=None):
+ """
+ Return ``det(M)`` assuming that either
+ there are lots of zeros or the size of the matrix
+ is small. If this assumption is not met, then the normal
+ Matrix.det function will be used with method = ``method``.
+
+ See Also
+ ========
+
+ det_minor
+ det_perm
+
+ """
+ if any(i.has(Symbol) for i in M):
+ if M.rows < 8 and all(i.has(Symbol) for i in M):
+ return det_perm(M)
+ return det_minor(M)
+ else:
+ return M.det(method=method) if method else M.det()
+
+
+def inv_quick(M):
+ """Return the inverse of ``M``, assuming that either
+ there are lots of zeros or the size of the matrix
+ is small.
+ """
+ if not all(i.is_Number for i in M):
+ if not any(i.is_Number for i in M):
+ det = lambda _: det_perm(_)
+ else:
+ det = lambda _: det_minor(_)
+ else:
+ return M.inv()
+ n = M.rows
+ d = det(M)
+ if d == S.Zero:
+ raise NonInvertibleMatrixError("Matrix det == 0; not invertible")
+ ret = zeros(n)
+ s1 = -1
+ for i in range(n):
+ s = s1 = -s1
+ for j in range(n):
+ di = det(M.minor_submatrix(i, j))
+ ret[j, i] = s*di/d
+ s = -s
+ return ret
+
+
+# these are functions that have multiple inverse values per period
+multi_inverses = {
+ sin: lambda x: (asin(x), S.Pi - asin(x)),
+ cos: lambda x: (acos(x), 2*S.Pi - acos(x)),
+}
+
+
+def _vsolve(e, s, **flags):
+ """return list of scalar values for the solution of e for symbol s"""
+ return [i[s] for i in _solve(e, s, **flags)]
+
+
+def _tsolve(eq, sym, **flags):
+ """
+ Helper for ``_solve`` that solves a transcendental equation with respect
+ to the given symbol. Various equations containing powers and logarithms,
+ can be solved.
+
+ There is currently no guarantee that all solutions will be returned or
+ that a real solution will be favored over a complex one.
+
+ Either a list of potential solutions will be returned or None will be
+ returned (in the case that no method was known to get a solution
+ for the equation). All other errors (like the inability to cast an
+ expression as a Poly) are unhandled.
+
+ Examples
+ ========
+
+ >>> from sympy import log, ordered
+ >>> from sympy.solvers.solvers import _tsolve as tsolve
+ >>> from sympy.abc import x
+
+ >>> list(ordered(tsolve(3**(2*x + 5) - 4, x)))
+ [-5/2 + log(2)/log(3), (-5*log(3)/2 + log(2) + I*pi)/log(3)]
+
+ >>> tsolve(log(x) + 2*x, x)
+ [LambertW(2)/2]
+
+ """
+ if 'tsolve_saw' not in flags:
+ flags['tsolve_saw'] = []
+ if eq in flags['tsolve_saw']:
+ return None
+ else:
+ flags['tsolve_saw'].append(eq)
+
+ rhs, lhs = _invert(eq, sym)
+
+ if lhs == sym:
+ return [rhs]
+ try:
+ if lhs.is_Add:
+ # it's time to try factoring; powdenest is used
+ # to try get powers in standard form for better factoring
+ f = factor(powdenest(lhs - rhs))
+ if f.is_Mul:
+ return _vsolve(f, sym, **flags)
+ if rhs:
+ f = logcombine(lhs, force=flags.get('force', True))
+ if f.count(log) != lhs.count(log):
+ if isinstance(f, log):
+ return _vsolve(f.args[0] - exp(rhs), sym, **flags)
+ return _tsolve(f - rhs, sym, **flags)
+
+ elif lhs.is_Pow:
+ if lhs.exp.is_Integer:
+ if lhs - rhs != eq:
+ return _vsolve(lhs - rhs, sym, **flags)
+
+ if sym not in lhs.exp.free_symbols:
+ return _vsolve(lhs.base - rhs**(1/lhs.exp), sym, **flags)
+
+ # _tsolve calls this with Dummy before passing the actual number in.
+ if any(t.is_Dummy for t in rhs.free_symbols):
+ raise NotImplementedError # _tsolve will call here again...
+
+ # a ** g(x) == 0
+ if not rhs:
+ # f(x)**g(x) only has solutions where f(x) == 0 and g(x) != 0 at
+ # the same place
+ sol_base = _vsolve(lhs.base, sym, **flags)
+ return [s for s in sol_base if lhs.exp.subs(sym, s) != 0] # XXX use checksol here?
+
+ # a ** g(x) == b
+ if not lhs.base.has(sym):
+ if lhs.base == 0:
+ return _vsolve(lhs.exp, sym, **flags) if rhs != 0 else []
+
+ # Gets most solutions...
+ if lhs.base == rhs.as_base_exp()[0]:
+ # handles case when bases are equal
+ sol = _vsolve(lhs.exp - rhs.as_base_exp()[1], sym, **flags)
+ else:
+ # handles cases when bases are not equal and exp
+ # may or may not be equal
+ f = exp(log(lhs.base)*lhs.exp) - exp(log(rhs))
+ sol = _vsolve(f, sym, **flags)
+
+ # Check for duplicate solutions
+ def equal(expr1, expr2):
+ _ = Dummy()
+ eq = checksol(expr1 - _, _, expr2)
+ if eq is None:
+ if nsimplify(expr1) != nsimplify(expr2):
+ return False
+ # they might be coincidentally the same
+ # so check more rigorously
+ eq = expr1.equals(expr2) # XXX expensive but necessary?
+ return eq
+
+ # Guess a rational exponent
+ e_rat = nsimplify(log(abs(rhs))/log(abs(lhs.base)))
+ e_rat = simplify(posify(e_rat)[0])
+ n, d = fraction(e_rat)
+ if expand(lhs.base**n - rhs**d) == 0:
+ sol = [s for s in sol if not equal(lhs.exp.subs(sym, s), e_rat)]
+ sol.extend(_vsolve(lhs.exp - e_rat, sym, **flags))
+
+ return list(set(sol))
+
+ # f(x) ** g(x) == c
+ else:
+ sol = []
+ logform = lhs.exp*log(lhs.base) - log(rhs)
+ if logform != lhs - rhs:
+ try:
+ sol.extend(_vsolve(logform, sym, **flags))
+ except NotImplementedError:
+ pass
+
+ # Collect possible solutions and check with substitution later.
+ check = []
+ if rhs == 1:
+ # f(x) ** g(x) = 1 -- g(x)=0 or f(x)=+-1
+ check.extend(_vsolve(lhs.exp, sym, **flags))
+ check.extend(_vsolve(lhs.base - 1, sym, **flags))
+ check.extend(_vsolve(lhs.base + 1, sym, **flags))
+ elif rhs.is_Rational:
+ for d in (i for i in divisors(abs(rhs.p)) if i != 1):
+ e, t = integer_log(rhs.p, d)
+ if not t:
+ continue # rhs.p != d**b
+ for s in divisors(abs(rhs.q)):
+ if s**e== rhs.q:
+ r = Rational(d, s)
+ check.extend(_vsolve(lhs.base - r, sym, **flags))
+ check.extend(_vsolve(lhs.base + r, sym, **flags))
+ check.extend(_vsolve(lhs.exp - e, sym, **flags))
+ elif rhs.is_irrational:
+ b_l, e_l = lhs.base.as_base_exp()
+ n, d = (e_l*lhs.exp).as_numer_denom()
+ b, e = sqrtdenest(rhs).as_base_exp()
+ check = [sqrtdenest(i) for i in (_vsolve(lhs.base - b, sym, **flags))]
+ check.extend([sqrtdenest(i) for i in (_vsolve(lhs.exp - e, sym, **flags))])
+ if e_l*d != 1:
+ check.extend(_vsolve(b_l**n - rhs**(e_l*d), sym, **flags))
+ for s in check:
+ ok = checksol(eq, sym, s)
+ if ok is None:
+ ok = eq.subs(sym, s).equals(0)
+ if ok:
+ sol.append(s)
+ return list(set(sol))
+
+ elif lhs.is_Function and len(lhs.args) == 1:
+ if lhs.func in multi_inverses:
+ # sin(x) = 1/3 -> x - asin(1/3) & x - (pi - asin(1/3))
+ soln = []
+ for i in multi_inverses[type(lhs)](rhs):
+ soln.extend(_vsolve(lhs.args[0] - i, sym, **flags))
+ return list(set(soln))
+ elif lhs.func == LambertW:
+ return _vsolve(lhs.args[0] - rhs*exp(rhs), sym, **flags)
+
+ rewrite = lhs.rewrite(exp)
+ if rewrite != lhs:
+ return _vsolve(rewrite - rhs, sym, **flags)
+ except NotImplementedError:
+ pass
+
+ # maybe it is a lambert pattern
+ if flags.pop('bivariate', True):
+ # lambert forms may need some help being recognized, e.g. changing
+ # 2**(3*x) + x**3*log(2)**3 + 3*x**2*log(2)**2 + 3*x*log(2) + 1
+ # to 2**(3*x) + (x*log(2) + 1)**3
+
+ # make generator in log have exponent of 1
+ logs = eq.atoms(log)
+ spow = min(
+ {i.exp for j in logs for i in j.atoms(Pow)
+ if i.base == sym} or {1})
+ if spow != 1:
+ p = sym**spow
+ u = Dummy('bivariate-cov')
+ ueq = eq.subs(p, u)
+ if not ueq.has_free(sym):
+ sol = _vsolve(ueq, u, **flags)
+ inv = _vsolve(p - u, sym)
+ return [i.subs(u, s) for i in inv for s in sol]
+
+ g = _filtered_gens(eq.as_poly(), sym)
+ up_or_log = set()
+ for gi in g:
+ if isinstance(gi, (exp, log)) or (gi.is_Pow and gi.base == S.Exp1):
+ up_or_log.add(gi)
+ elif gi.is_Pow:
+ gisimp = powdenest(expand_power_exp(gi))
+ if gisimp.is_Pow and sym in gisimp.exp.free_symbols:
+ up_or_log.add(gi)
+ eq_down = expand_log(expand_power_exp(eq)).subs(
+ dict(list(zip(up_or_log, [0]*len(up_or_log)))))
+ eq = expand_power_exp(factor(eq_down, deep=True) + (eq - eq_down))
+ rhs, lhs = _invert(eq, sym)
+ if lhs.has(sym):
+ try:
+ poly = lhs.as_poly()
+ g = _filtered_gens(poly, sym)
+ _eq = lhs - rhs
+ sols = _solve_lambert(_eq, sym, g)
+ # use a simplified form if it satisfies eq
+ # and has fewer operations
+ for n, s in enumerate(sols):
+ ns = nsimplify(s)
+ if ns != s and ns.count_ops() <= s.count_ops():
+ ok = checksol(_eq, sym, ns)
+ if ok is None:
+ ok = _eq.subs(sym, ns).equals(0)
+ if ok:
+ sols[n] = ns
+ return sols
+ except NotImplementedError:
+ # maybe it's a convoluted function
+ if len(g) == 2:
+ try:
+ gpu = bivariate_type(lhs - rhs, *g)
+ if gpu is None:
+ raise NotImplementedError
+ g, p, u = gpu
+ flags['bivariate'] = False
+ inversion = _tsolve(g - u, sym, **flags)
+ if inversion:
+ sol = _vsolve(p, u, **flags)
+ return list({i.subs(u, s)
+ for i in inversion for s in sol})
+ except NotImplementedError:
+ pass
+ else:
+ pass
+
+ if flags.pop('force', True):
+ flags['force'] = False
+ pos, reps = posify(lhs - rhs)
+ if rhs == S.ComplexInfinity:
+ return []
+ for u, s in reps.items():
+ if s == sym:
+ break
+ else:
+ u = sym
+ if pos.has(u):
+ try:
+ soln = _vsolve(pos, u, **flags)
+ return [s.subs(reps) for s in soln]
+ except NotImplementedError:
+ pass
+ else:
+ pass # here for coverage
+
+ return # here for coverage
+
+
+# TODO: option for calculating J numerically
+
+@conserve_mpmath_dps
+def nsolve(*args, dict=False, **kwargs):
+ r"""
+ Solve a nonlinear equation system numerically: ``nsolve(f, [args,] x0,
+ modules=['mpmath'], **kwargs)``.
+
+ Explanation
+ ===========
+
+ ``f`` is a vector function of symbolic expressions representing the system.
+ *args* are the variables. If there is only one variable, this argument can
+ be omitted. ``x0`` is a starting vector close to a solution.
+
+ Use the modules keyword to specify which modules should be used to
+ evaluate the function and the Jacobian matrix. Make sure to use a module
+ that supports matrices. For more information on the syntax, please see the
+ docstring of ``lambdify``.
+
+ If the keyword arguments contain ``dict=True`` (default is False) ``nsolve``
+ will return a list (perhaps empty) of solution mappings. This might be
+ especially useful if you want to use ``nsolve`` as a fallback to solve since
+ using the dict argument for both methods produces return values of
+ consistent type structure. Please note: to keep this consistent with
+ ``solve``, the solution will be returned in a list even though ``nsolve``
+ (currently at least) only finds one solution at a time.
+
+ Overdetermined systems are supported.
+
+ Examples
+ ========
+
+ >>> from sympy import Symbol, nsolve
+ >>> import mpmath
+ >>> mpmath.mp.dps = 15
+ >>> x1 = Symbol('x1')
+ >>> x2 = Symbol('x2')
+ >>> f1 = 3 * x1**2 - 2 * x2**2 - 1
+ >>> f2 = x1**2 - 2 * x1 + x2**2 + 2 * x2 - 8
+ >>> print(nsolve((f1, f2), (x1, x2), (-1, 1)))
+ Matrix([[-1.19287309935246], [1.27844411169911]])
+
+ For one-dimensional functions the syntax is simplified:
+
+ >>> from sympy import sin, nsolve
+ >>> from sympy.abc import x
+ >>> nsolve(sin(x), x, 2)
+ 3.14159265358979
+ >>> nsolve(sin(x), 2)
+ 3.14159265358979
+
+ To solve with higher precision than the default, use the prec argument:
+
+ >>> from sympy import cos
+ >>> nsolve(cos(x) - x, 1)
+ 0.739085133215161
+ >>> nsolve(cos(x) - x, 1, prec=50)
+ 0.73908513321516064165531208767387340401341175890076
+ >>> cos(_)
+ 0.73908513321516064165531208767387340401341175890076
+
+ To solve for complex roots of real functions, a nonreal initial point
+ must be specified:
+
+ >>> from sympy import I
+ >>> nsolve(x**2 + 2, I)
+ 1.4142135623731*I
+
+ ``mpmath.findroot`` is used and you can find their more extensive
+ documentation, especially concerning keyword parameters and
+ available solvers. Note, however, that functions which are very
+ steep near the root, the verification of the solution may fail. In
+ this case you should use the flag ``verify=False`` and
+ independently verify the solution.
+
+ >>> from sympy import cos, cosh
+ >>> f = cos(x)*cosh(x) - 1
+ >>> nsolve(f, 3.14*100)
+ Traceback (most recent call last):
+ ...
+ ValueError: Could not find root within given tolerance. (1.39267e+230 > 2.1684e-19)
+ >>> ans = nsolve(f, 3.14*100, verify=False); ans
+ 312.588469032184
+ >>> f.subs(x, ans).n(2)
+ 2.1e+121
+ >>> (f/f.diff(x)).subs(x, ans).n(2)
+ 7.4e-15
+
+ One might safely skip the verification if bounds of the root are known
+ and a bisection method is used:
+
+ >>> bounds = lambda i: (3.14*i, 3.14*(i + 1))
+ >>> nsolve(f, bounds(100), solver='bisect', verify=False)
+ 315.730061685774
+
+ Alternatively, a function may be better behaved when the
+ denominator is ignored. Since this is not always the case, however,
+ the decision of what function to use is left to the discretion of
+ the user.
+
+ >>> eq = x**2/(1 - x)/(1 - 2*x)**2 - 100
+ >>> nsolve(eq, 0.46)
+ Traceback (most recent call last):
+ ...
+ ValueError: Could not find root within given tolerance. (10000 > 2.1684e-19)
+ Try another starting point or tweak arguments.
+ >>> nsolve(eq.as_numer_denom()[0], 0.46)
+ 0.46792545969349058
+
+ """
+ # there are several other SymPy functions that use method= so
+ # guard against that here
+ if 'method' in kwargs:
+ raise ValueError(filldedent('''
+ Keyword "method" should not be used in this context. When using
+ some mpmath solvers directly, the keyword "method" is
+ used, but when using nsolve (and findroot) the keyword to use is
+ "solver".'''))
+
+ if 'prec' in kwargs:
+ import mpmath
+ mpmath.mp.dps = kwargs.pop('prec')
+
+ # keyword argument to return result as a dictionary
+ as_dict = dict
+ from builtins import dict # to unhide the builtin
+
+ # interpret arguments
+ if len(args) == 3:
+ f = args[0]
+ fargs = args[1]
+ x0 = args[2]
+ if iterable(fargs) and iterable(x0):
+ if len(x0) != len(fargs):
+ raise TypeError('nsolve expected exactly %i guess vectors, got %i'
+ % (len(fargs), len(x0)))
+ elif len(args) == 2:
+ f = args[0]
+ fargs = None
+ x0 = args[1]
+ if iterable(f):
+ raise TypeError('nsolve expected 3 arguments, got 2')
+ elif len(args) < 2:
+ raise TypeError('nsolve expected at least 2 arguments, got %i'
+ % len(args))
+ else:
+ raise TypeError('nsolve expected at most 3 arguments, got %i'
+ % len(args))
+ modules = kwargs.get('modules', ['mpmath'])
+ if iterable(f):
+ f = list(f)
+ for i, fi in enumerate(f):
+ if isinstance(fi, Eq):
+ f[i] = fi.lhs - fi.rhs
+ f = Matrix(f).T
+ if iterable(x0):
+ x0 = list(x0)
+ if not isinstance(f, Matrix):
+ # assume it's a SymPy expression
+ if isinstance(f, Eq):
+ f = f.lhs - f.rhs
+ syms = f.free_symbols
+ if fargs is None:
+ fargs = syms.copy().pop()
+ if not (len(syms) == 1 and (fargs in syms or fargs[0] in syms)):
+ raise ValueError(filldedent('''
+ expected a one-dimensional and numerical function'''))
+
+ # the function is much better behaved if there is no denominator
+ # but sending the numerator is left to the user since sometimes
+ # the function is better behaved when the denominator is present
+ # e.g., issue 11768
+
+ f = lambdify(fargs, f, modules)
+ x = sympify(findroot(f, x0, **kwargs))
+ if as_dict:
+ return [{fargs: x}]
+ return x
+
+ if len(fargs) > f.cols:
+ raise NotImplementedError(filldedent('''
+ need at least as many equations as variables'''))
+ verbose = kwargs.get('verbose', False)
+ if verbose:
+ print('f(x):')
+ print(f)
+ # derive Jacobian
+ J = f.jacobian(fargs)
+ if verbose:
+ print('J(x):')
+ print(J)
+ # create functions
+ f = lambdify(fargs, f.T, modules)
+ J = lambdify(fargs, J, modules)
+ # solve the system numerically
+ x = findroot(f, x0, J=J, **kwargs)
+ if as_dict:
+ return [dict(zip(fargs, [sympify(xi) for xi in x]))]
+ return Matrix(x)
+
+
+def _invert(eq, *symbols, **kwargs):
+ """
+ Return tuple (i, d) where ``i`` is independent of *symbols* and ``d``
+ contains symbols.
+
+ Explanation
+ ===========
+
+ ``i`` and ``d`` are obtained after recursively using algebraic inversion
+ until an uninvertible ``d`` remains. If there are no free symbols then
+ ``d`` will be zero. Some (but not necessarily all) solutions to the
+ expression ``i - d`` will be related to the solutions of the original
+ expression.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.solvers import _invert as invert
+ >>> from sympy import sqrt, cos
+ >>> from sympy.abc import x, y
+ >>> invert(x - 3)
+ (3, x)
+ >>> invert(3)
+ (3, 0)
+ >>> invert(2*cos(x) - 1)
+ (1/2, cos(x))
+ >>> invert(sqrt(x) - 3)
+ (3, sqrt(x))
+ >>> invert(sqrt(x) + y, x)
+ (-y, sqrt(x))
+ >>> invert(sqrt(x) + y, y)
+ (-sqrt(x), y)
+ >>> invert(sqrt(x) + y, x, y)
+ (0, sqrt(x) + y)
+
+ If there is more than one symbol in a power's base and the exponent
+ is not an Integer, then the principal root will be used for the
+ inversion:
+
+ >>> invert(sqrt(x + y) - 2)
+ (4, x + y)
+ >>> invert(sqrt(x + y) - 2)
+ (4, x + y)
+
+ If the exponent is an Integer, setting ``integer_power`` to True
+ will force the principal root to be selected:
+
+ >>> invert(x**2 - 4, integer_power=True)
+ (2, x)
+
+ """
+ eq = sympify(eq)
+ if eq.args:
+ # make sure we are working with flat eq
+ eq = eq.func(*eq.args)
+ free = eq.free_symbols
+ if not symbols:
+ symbols = free
+ if not free & set(symbols):
+ return eq, S.Zero
+
+ dointpow = bool(kwargs.get('integer_power', False))
+
+ lhs = eq
+ rhs = S.Zero
+ while True:
+ was = lhs
+ while True:
+ indep, dep = lhs.as_independent(*symbols)
+
+ # dep + indep == rhs
+ if lhs.is_Add:
+ # this indicates we have done it all
+ if indep.is_zero:
+ break
+
+ lhs = dep
+ rhs -= indep
+
+ # dep * indep == rhs
+ else:
+ # this indicates we have done it all
+ if indep is S.One:
+ break
+
+ lhs = dep
+ rhs /= indep
+
+ # collect like-terms in symbols
+ if lhs.is_Add:
+ terms = {}
+ for a in lhs.args:
+ i, d = a.as_independent(*symbols)
+ terms.setdefault(d, []).append(i)
+ if any(len(v) > 1 for v in terms.values()):
+ args = []
+ for d, i in terms.items():
+ if len(i) > 1:
+ args.append(Add(*i)*d)
+ else:
+ args.append(i[0]*d)
+ lhs = Add(*args)
+
+ # if it's a two-term Add with rhs = 0 and two powers we can get the
+ # dependent terms together, e.g. 3*f(x) + 2*g(x) -> f(x)/g(x) = -2/3
+ if lhs.is_Add and not rhs and len(lhs.args) == 2 and \
+ not lhs.is_polynomial(*symbols):
+ a, b = ordered(lhs.args)
+ ai, ad = a.as_independent(*symbols)
+ bi, bd = b.as_independent(*symbols)
+ if any(_ispow(i) for i in (ad, bd)):
+ a_base, a_exp = ad.as_base_exp()
+ b_base, b_exp = bd.as_base_exp()
+ if a_base == b_base:
+ # a = -b
+ lhs = powsimp(powdenest(ad/bd))
+ rhs = -bi/ai
+ else:
+ rat = ad/bd
+ _lhs = powsimp(ad/bd)
+ if _lhs != rat:
+ lhs = _lhs
+ rhs = -bi/ai
+ elif ai == -bi:
+ if isinstance(ad, Function) and ad.func == bd.func:
+ if len(ad.args) == len(bd.args) == 1:
+ lhs = ad.args[0] - bd.args[0]
+ elif len(ad.args) == len(bd.args):
+ # should be able to solve
+ # f(x, y) - f(2 - x, 0) == 0 -> x == 1
+ raise NotImplementedError(
+ 'equal function with more than 1 argument')
+ else:
+ raise ValueError(
+ 'function with different numbers of args')
+
+ elif lhs.is_Mul and any(_ispow(a) for a in lhs.args):
+ lhs = powsimp(powdenest(lhs))
+
+ if lhs.is_Function:
+ if hasattr(lhs, 'inverse') and lhs.inverse() is not None and len(lhs.args) == 1:
+ # -1
+ # f(x) = g -> x = f (g)
+ #
+ # /!\ inverse should not be defined if there are multiple values
+ # for the function -- these are handled in _tsolve
+ #
+ rhs = lhs.inverse()(rhs)
+ lhs = lhs.args[0]
+ elif isinstance(lhs, atan2):
+ y, x = lhs.args
+ lhs = 2*atan(y/(sqrt(x**2 + y**2) + x))
+ elif lhs.func == rhs.func:
+ if len(lhs.args) == len(rhs.args) == 1:
+ lhs = lhs.args[0]
+ rhs = rhs.args[0]
+ elif len(lhs.args) == len(rhs.args):
+ # should be able to solve
+ # f(x, y) == f(2, 3) -> x == 2
+ # f(x, x + y) == f(2, 3) -> x == 2
+ raise NotImplementedError(
+ 'equal function with more than 1 argument')
+ else:
+ raise ValueError(
+ 'function with different numbers of args')
+
+
+ if rhs and lhs.is_Pow and lhs.exp.is_Integer and lhs.exp < 0:
+ lhs = 1/lhs
+ rhs = 1/rhs
+
+ # base**a = b -> base = b**(1/a) if
+ # a is an Integer and dointpow=True (this gives real branch of root)
+ # a is not an Integer and the equation is multivariate and the
+ # base has more than 1 symbol in it
+ # The rationale for this is that right now the multi-system solvers
+ # doesn't try to resolve generators to see, for example, if the whole
+ # system is written in terms of sqrt(x + y) so it will just fail, so we
+ # do that step here.
+ if lhs.is_Pow and (
+ lhs.exp.is_Integer and dointpow or not lhs.exp.is_Integer and
+ len(symbols) > 1 and len(lhs.base.free_symbols & set(symbols)) > 1):
+ rhs = rhs**(1/lhs.exp)
+ lhs = lhs.base
+
+ if lhs == was:
+ break
+ return rhs, lhs
+
+
+def unrad(eq, *syms, **flags):
+ """
+ Remove radicals with symbolic arguments and return (eq, cov),
+ None, or raise an error.
+
+ Explanation
+ ===========
+
+ None is returned if there are no radicals to remove.
+
+ NotImplementedError is raised if there are radicals and they cannot be
+ removed or if the relationship between the original symbols and the
+ change of variable needed to rewrite the system as a polynomial cannot
+ be solved.
+
+ Otherwise the tuple, ``(eq, cov)``, is returned where:
+
+ *eq*, ``cov``
+ *eq* is an equation without radicals (in the symbol(s) of
+ interest) whose solutions are a superset of the solutions to the
+ original expression. *eq* might be rewritten in terms of a new
+ variable; the relationship to the original variables is given by
+ ``cov`` which is a list containing ``v`` and ``v**p - b`` where
+ ``p`` is the power needed to clear the radical and ``b`` is the
+ radical now expressed as a polynomial in the symbols of interest.
+ For example, for sqrt(2 - x) the tuple would be
+ ``(c, c**2 - 2 + x)``. The solutions of *eq* will contain
+ solutions to the original equation (if there are any).
+
+ *syms*
+ An iterable of symbols which, if provided, will limit the focus of
+ radical removal: only radicals with one or more of the symbols of
+ interest will be cleared. All free symbols are used if *syms* is not
+ set.
+
+ *flags* are used internally for communication during recursive calls.
+ Two options are also recognized:
+
+ ``take``, when defined, is interpreted as a single-argument function
+ that returns True if a given Pow should be handled.
+
+ Radicals can be removed from an expression if:
+
+ * All bases of the radicals are the same; a change of variables is
+ done in this case.
+ * If all radicals appear in one term of the expression.
+ * There are only four terms with sqrt() factors or there are less than
+ four terms having sqrt() factors.
+ * There are only two terms with radicals.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.solvers import unrad
+ >>> from sympy.abc import x
+ >>> from sympy import sqrt, Rational, root
+
+ >>> unrad(sqrt(x)*x**Rational(1, 3) + 2)
+ (x**5 - 64, [])
+ >>> unrad(sqrt(x) + root(x + 1, 3))
+ (-x**3 + x**2 + 2*x + 1, [])
+ >>> eq = sqrt(x) + root(x, 3) - 2
+ >>> unrad(eq)
+ (_p**3 + _p**2 - 2, [_p, _p**6 - x])
+
+ """
+
+ uflags = {"check": False, "simplify": False}
+
+ def _cov(p, e):
+ if cov:
+ # XXX - uncovered
+ oldp, olde = cov
+ if Poly(e, p).degree(p) in (1, 2):
+ cov[:] = [p, olde.subs(oldp, _vsolve(e, p, **uflags)[0])]
+ else:
+ raise NotImplementedError
+ else:
+ cov[:] = [p, e]
+
+ def _canonical(eq, cov):
+ if cov:
+ # change symbol to vanilla so no solutions are eliminated
+ p, e = cov
+ rep = {p: Dummy(p.name)}
+ eq = eq.xreplace(rep)
+ cov = [p.xreplace(rep), e.xreplace(rep)]
+
+ # remove constants and powers of factors since these don't change
+ # the location of the root; XXX should factor or factor_terms be used?
+ eq = factor_terms(_mexpand(eq.as_numer_denom()[0], recursive=True), clear=True)
+ if eq.is_Mul:
+ args = []
+ for f in eq.args:
+ if f.is_number:
+ continue
+ if f.is_Pow:
+ args.append(f.base)
+ else:
+ args.append(f)
+ eq = Mul(*args) # leave as Mul for more efficient solving
+
+ # make the sign canonical
+ margs = list(Mul.make_args(eq))
+ changed = False
+ for i, m in enumerate(margs):
+ if m.could_extract_minus_sign():
+ margs[i] = -m
+ changed = True
+ if changed:
+ eq = Mul(*margs, evaluate=False)
+
+ return eq, cov
+
+ def _Q(pow):
+ # return leading Rational of denominator of Pow's exponent
+ c = pow.as_base_exp()[1].as_coeff_Mul()[0]
+ if not c.is_Rational:
+ return S.One
+ return c.q
+
+ # define the _take method that will determine whether a term is of interest
+ def _take(d):
+ # return True if coefficient of any factor's exponent's den is not 1
+ for pow in Mul.make_args(d):
+ if not pow.is_Pow:
+ continue
+ if _Q(pow) == 1:
+ continue
+ if pow.free_symbols & syms:
+ return True
+ return False
+ _take = flags.setdefault('_take', _take)
+
+ if isinstance(eq, Eq):
+ eq = eq.lhs - eq.rhs # XXX legacy Eq as Eqn support
+ elif not isinstance(eq, Expr):
+ return
+
+ cov, nwas, rpt = [flags.setdefault(k, v) for k, v in
+ sorted({"cov": [], "n": None, "rpt": 0}.items())]
+
+ # preconditioning
+ eq = powdenest(factor_terms(eq, radical=True, clear=True))
+ eq = eq.as_numer_denom()[0]
+ eq = _mexpand(eq, recursive=True)
+ if eq.is_number:
+ return
+
+ # see if there are radicals in symbols of interest
+ syms = set(syms) or eq.free_symbols # _take uses this
+ poly = eq.as_poly()
+ gens = [g for g in poly.gens if _take(g)]
+ if not gens:
+ return
+
+ # recast poly in terms of eigen-gens
+ poly = eq.as_poly(*gens)
+
+ # not a polynomial e.g. 1 + sqrt(x)*exp(sqrt(x)) with gen sqrt(x)
+ if poly is None:
+ return
+
+ # - an exponent has a symbol of interest (don't handle)
+ if any(g.exp.has(*syms) for g in gens):
+ return
+
+ def _rads_bases_lcm(poly):
+ # if all the bases are the same or all the radicals are in one
+ # term, `lcm` will be the lcm of the denominators of the
+ # exponents of the radicals
+ lcm = 1
+ rads = set()
+ bases = set()
+ for g in poly.gens:
+ q = _Q(g)
+ if q != 1:
+ rads.add(g)
+ lcm = ilcm(lcm, q)
+ bases.add(g.base)
+ return rads, bases, lcm
+ rads, bases, lcm = _rads_bases_lcm(poly)
+
+ covsym = Dummy('p', nonnegative=True)
+
+ # only keep in syms symbols that actually appear in radicals;
+ # and update gens
+ newsyms = set()
+ for r in rads:
+ newsyms.update(syms & r.free_symbols)
+ if newsyms != syms:
+ syms = newsyms
+ # get terms together that have common generators
+ drad = dict(zip(rads, range(len(rads))))
+ rterms = {(): []}
+ args = Add.make_args(poly.as_expr())
+ for t in args:
+ if _take(t):
+ common = set(t.as_poly().gens).intersection(rads)
+ key = tuple(sorted([drad[i] for i in common]))
+ else:
+ key = ()
+ rterms.setdefault(key, []).append(t)
+ others = Add(*rterms.pop(()))
+ rterms = [Add(*rterms[k]) for k in rterms.keys()]
+
+ # the output will depend on the order terms are processed, so
+ # make it canonical quickly
+ rterms = list(reversed(list(ordered(rterms))))
+
+ ok = False # we don't have a solution yet
+ depth = sqrt_depth(eq)
+
+ if len(rterms) == 1 and not (rterms[0].is_Add and lcm > 2):
+ eq = rterms[0]**lcm - ((-others)**lcm)
+ ok = True
+ else:
+ if len(rterms) == 1 and rterms[0].is_Add:
+ rterms = list(rterms[0].args)
+ if len(bases) == 1:
+ b = bases.pop()
+ if len(syms) > 1:
+ x = b.free_symbols
+ else:
+ x = syms
+ x = list(ordered(x))[0]
+ try:
+ inv = _vsolve(covsym**lcm - b, x, **uflags)
+ if not inv:
+ raise NotImplementedError
+ eq = poly.as_expr().subs(b, covsym**lcm).subs(x, inv[0])
+ _cov(covsym, covsym**lcm - b)
+ return _canonical(eq, cov)
+ except NotImplementedError:
+ pass
+
+ if len(rterms) == 2:
+ if not others:
+ eq = rterms[0]**lcm - (-rterms[1])**lcm
+ ok = True
+ elif not log(lcm, 2).is_Integer:
+ # the lcm-is-power-of-two case is handled below
+ r0, r1 = rterms
+ if flags.get('_reverse', False):
+ r1, r0 = r0, r1
+ i0 = _rads0, _bases0, lcm0 = _rads_bases_lcm(r0.as_poly())
+ i1 = _rads1, _bases1, lcm1 = _rads_bases_lcm(r1.as_poly())
+ for reverse in range(2):
+ if reverse:
+ i0, i1 = i1, i0
+ r0, r1 = r1, r0
+ _rads1, _, lcm1 = i1
+ _rads1 = Mul(*_rads1)
+ t1 = _rads1**lcm1
+ c = covsym**lcm1 - t1
+ for x in syms:
+ try:
+ sol = _vsolve(c, x, **uflags)
+ if not sol:
+ raise NotImplementedError
+ neweq = r0.subs(x, sol[0]) + covsym*r1/_rads1 + \
+ others
+ tmp = unrad(neweq, covsym)
+ if tmp:
+ eq, newcov = tmp
+ if newcov:
+ newp, newc = newcov
+ _cov(newp, c.subs(covsym,
+ _vsolve(newc, covsym, **uflags)[0]))
+ else:
+ _cov(covsym, c)
+ else:
+ eq = neweq
+ _cov(covsym, c)
+ ok = True
+ break
+ except NotImplementedError:
+ if reverse:
+ raise NotImplementedError(
+ 'no successful change of variable found')
+ else:
+ pass
+ if ok:
+ break
+ elif len(rterms) == 3:
+ # two cube roots and another with order less than 5
+ # (so an analytical solution can be found) or a base
+ # that matches one of the cube root bases
+ info = [_rads_bases_lcm(i.as_poly()) for i in rterms]
+ RAD = 0
+ BASES = 1
+ LCM = 2
+ if info[0][LCM] != 3:
+ info.append(info.pop(0))
+ rterms.append(rterms.pop(0))
+ elif info[1][LCM] != 3:
+ info.append(info.pop(1))
+ rterms.append(rterms.pop(1))
+ if info[0][LCM] == info[1][LCM] == 3:
+ if info[1][BASES] != info[2][BASES]:
+ info[0], info[1] = info[1], info[0]
+ rterms[0], rterms[1] = rterms[1], rterms[0]
+ if info[1][BASES] == info[2][BASES]:
+ eq = rterms[0]**3 + (rterms[1] + rterms[2] + others)**3
+ ok = True
+ elif info[2][LCM] < 5:
+ # a*root(A, 3) + b*root(B, 3) + others = c
+ a, b, c, d, A, B = [Dummy(i) for i in 'abcdAB']
+ # zz represents the unraded expression into which the
+ # specifics for this case are substituted
+ zz = (c - d)*(A**3*a**9 + 3*A**2*B*a**6*b**3 -
+ 3*A**2*a**6*c**3 + 9*A**2*a**6*c**2*d - 9*A**2*a**6*c*d**2 +
+ 3*A**2*a**6*d**3 + 3*A*B**2*a**3*b**6 + 21*A*B*a**3*b**3*c**3 -
+ 63*A*B*a**3*b**3*c**2*d + 63*A*B*a**3*b**3*c*d**2 -
+ 21*A*B*a**3*b**3*d**3 + 3*A*a**3*c**6 - 18*A*a**3*c**5*d +
+ 45*A*a**3*c**4*d**2 - 60*A*a**3*c**3*d**3 + 45*A*a**3*c**2*d**4 -
+ 18*A*a**3*c*d**5 + 3*A*a**3*d**6 + B**3*b**9 - 3*B**2*b**6*c**3 +
+ 9*B**2*b**6*c**2*d - 9*B**2*b**6*c*d**2 + 3*B**2*b**6*d**3 +
+ 3*B*b**3*c**6 - 18*B*b**3*c**5*d + 45*B*b**3*c**4*d**2 -
+ 60*B*b**3*c**3*d**3 + 45*B*b**3*c**2*d**4 - 18*B*b**3*c*d**5 +
+ 3*B*b**3*d**6 - c**9 + 9*c**8*d - 36*c**7*d**2 + 84*c**6*d**3 -
+ 126*c**5*d**4 + 126*c**4*d**5 - 84*c**3*d**6 + 36*c**2*d**7 -
+ 9*c*d**8 + d**9)
+ def _t(i):
+ b = Mul(*info[i][RAD])
+ return cancel(rterms[i]/b), Mul(*info[i][BASES])
+ aa, AA = _t(0)
+ bb, BB = _t(1)
+ cc = -rterms[2]
+ dd = others
+ eq = zz.xreplace(dict(zip(
+ (a, A, b, B, c, d),
+ (aa, AA, bb, BB, cc, dd))))
+ ok = True
+ # handle power-of-2 cases
+ if not ok:
+ if log(lcm, 2).is_Integer and (not others and
+ len(rterms) == 4 or len(rterms) < 4):
+ def _norm2(a, b):
+ return a**2 + b**2 + 2*a*b
+
+ if len(rterms) == 4:
+ # (r0+r1)**2 - (r2+r3)**2
+ r0, r1, r2, r3 = rterms
+ eq = _norm2(r0, r1) - _norm2(r2, r3)
+ ok = True
+ elif len(rterms) == 3:
+ # (r1+r2)**2 - (r0+others)**2
+ r0, r1, r2 = rterms
+ eq = _norm2(r1, r2) - _norm2(r0, others)
+ ok = True
+ elif len(rterms) == 2:
+ # r0**2 - (r1+others)**2
+ r0, r1 = rterms
+ eq = r0**2 - _norm2(r1, others)
+ ok = True
+
+ new_depth = sqrt_depth(eq) if ok else depth
+ rpt += 1 # XXX how many repeats with others unchanging is enough?
+ if not ok or (
+ nwas is not None and len(rterms) == nwas and
+ new_depth is not None and new_depth == depth and
+ rpt > 3):
+ raise NotImplementedError('Cannot remove all radicals')
+
+ flags.update({"cov": cov, "n": len(rterms), "rpt": rpt})
+ neq = unrad(eq, *syms, **flags)
+ if neq:
+ eq, cov = neq
+ eq, cov = _canonical(eq, cov)
+ return eq, cov
+
+
+# delayed imports
+from sympy.solvers.bivariate import (
+ bivariate_type, _solve_lambert, _filtered_gens)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/solvers/solveset.py b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/solveset.py
new file mode 100644
index 0000000000000000000000000000000000000000..58cfce9eb11d0f811c319350424133779e5c2d63
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/solvers/solveset.py
@@ -0,0 +1,3878 @@
+"""
+This module contains functions to:
+
+ - solve a single equation for a single variable, in any domain either real or complex.
+
+ - solve a single transcendental equation for a single variable in any domain either real or complex.
+ (currently supports solving in real domain only)
+
+ - solve a system of linear equations with N variables and M equations.
+
+ - solve a system of Non Linear Equations with N variables and M equations
+"""
+from sympy.core.sympify import sympify
+from sympy.core import (S, Pow, Dummy, pi, Expr, Wild, Mul, Equality,
+ Add, Basic)
+from sympy.core.containers import Tuple
+from sympy.core.function import (Lambda, expand_complex, AppliedUndef,
+ expand_log, _mexpand, expand_trig, nfloat)
+from sympy.core.mod import Mod
+from sympy.core.numbers import igcd, I, Number, Rational, oo, ilcm
+from sympy.core.power import integer_log
+from sympy.core.relational import Eq, Ne, Relational
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.core.symbol import Symbol, _uniquely_named_symbol
+from sympy.core.sympify import _sympify
+from sympy.polys.matrices.linsolve import _linear_eq_to_dict
+from sympy.polys.polyroots import UnsolvableFactorError
+from sympy.simplify.simplify import simplify, fraction, trigsimp, nsimplify
+from sympy.simplify import powdenest, logcombine
+from sympy.functions import (log, tan, cot, sin, cos, sec, csc, exp,
+ acos, asin, acsc, asec,
+ piecewise_fold, Piecewise)
+from sympy.functions.elementary.complexes import Abs, arg, re, im
+from sympy.functions.elementary.hyperbolic import HyperbolicFunction
+from sympy.functions.elementary.miscellaneous import real_root
+from sympy.functions.elementary.trigonometric import TrigonometricFunction
+from sympy.logic.boolalg import And, BooleanTrue
+from sympy.sets import (FiniteSet, imageset, Interval, Intersection,
+ Union, ConditionSet, ImageSet, Complement, Contains)
+from sympy.sets.sets import Set, ProductSet
+from sympy.matrices import zeros, Matrix, MatrixBase
+from sympy.ntheory import totient
+from sympy.ntheory.factor_ import divisors
+from sympy.ntheory.residue_ntheory import discrete_log, nthroot_mod
+from sympy.polys import (roots, Poly, degree, together, PolynomialError,
+ RootOf, factor, lcm, gcd)
+from sympy.polys.polyerrors import CoercionFailed
+from sympy.polys.polytools import invert, groebner, poly
+from sympy.polys.solvers import (sympy_eqs_to_ring, solve_lin_sys,
+ PolyNonlinearError)
+from sympy.polys.matrices.linsolve import _linsolve
+from sympy.solvers.solvers import (checksol, denoms, unrad,
+ _simple_dens, recast_to_symbols)
+from sympy.solvers.polysys import solve_poly_system
+from sympy.utilities import filldedent
+from sympy.utilities.iterables import (numbered_symbols, has_dups,
+ is_sequence, iterable)
+from sympy.calculus.util import periodicity, continuous_domain, function_range
+
+from types import GeneratorType
+
+
+class NonlinearError(ValueError):
+ """Raised when unexpectedly encountering nonlinear equations"""
+ pass
+
+
+_rc = Dummy("R", real=True), Dummy("C", complex=True)
+
+
+def _masked(f, *atoms):
+ """Return ``f``, with all objects given by ``atoms`` replaced with
+ Dummy symbols, ``d``, and the list of replacements, ``(d, e)``,
+ where ``e`` is an object of type given by ``atoms`` in which
+ any other instances of atoms have been recursively replaced with
+ Dummy symbols, too. The tuples are ordered so that if they are
+ applied in sequence, the origin ``f`` will be restored.
+
+ Examples
+ ========
+
+ >>> from sympy import cos
+ >>> from sympy.abc import x
+ >>> from sympy.solvers.solveset import _masked
+
+ >>> f = cos(cos(x) + 1)
+ >>> f, reps = _masked(cos(1 + cos(x)), cos)
+ >>> f
+ _a1
+ >>> reps
+ [(_a1, cos(_a0 + 1)), (_a0, cos(x))]
+ >>> for d, e in reps:
+ ... f = f.xreplace({d: e})
+ >>> f
+ cos(cos(x) + 1)
+ """
+ sym = numbered_symbols('a', cls=Dummy, real=True)
+ mask = []
+ for a in ordered(f.atoms(*atoms)):
+ for i in mask:
+ a = a.replace(*i)
+ mask.append((a, next(sym)))
+ for i, (o, n) in enumerate(mask):
+ f = f.replace(o, n)
+ mask[i] = (n, o)
+ mask = list(reversed(mask))
+ return f, mask
+
+
+def _invert(f_x, y, x, domain=S.Complexes):
+ r"""
+ Reduce the complex valued equation $f(x) = y$ to a set of equations
+
+ $$\left\{g(x) = h_1(y),\ g(x) = h_2(y),\ \dots,\ g(x) = h_n(y) \right\}$$
+
+ where $g(x)$ is a simpler function than $f(x)$. The return value is a tuple
+ $(g(x), \mathrm{set}_h)$, where $g(x)$ is a function of $x$ and $\mathrm{set}_h$ is
+ the set of function $\left\{h_1(y), h_2(y), \dots, h_n(y)\right\}$.
+ Here, $y$ is not necessarily a symbol.
+
+ $\mathrm{set}_h$ contains the functions, along with the information
+ about the domain in which they are valid, through set
+ operations. For instance, if :math:`y = |x| - n` is inverted
+ in the real domain, then $\mathrm{set}_h$ is not simply
+ $\{-n, n\}$ as the nature of `n` is unknown; rather, it is:
+
+ $$ \left(\left[0, \infty\right) \cap \left\{n\right\}\right) \cup
+ \left(\left(-\infty, 0\right] \cap \left\{- n\right\}\right)$$
+
+ By default, the complex domain is used which means that inverting even
+ seemingly simple functions like $\exp(x)$ will give very different
+ results from those obtained in the real domain.
+ (In the case of $\exp(x)$, the inversion via $\log$ is multi-valued
+ in the complex domain, having infinitely many branches.)
+
+ If you are working with real values only (or you are not sure which
+ function to use) you should probably set the domain to
+ ``S.Reals`` (or use ``invert_real`` which does that automatically).
+
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.solveset import invert_complex, invert_real
+ >>> from sympy.abc import x, y
+ >>> from sympy import exp
+
+ When does exp(x) == y?
+
+ >>> invert_complex(exp(x), y, x)
+ (x, ImageSet(Lambda(_n, I*(2*_n*pi + arg(y)) + log(Abs(y))), Integers))
+ >>> invert_real(exp(x), y, x)
+ (x, Intersection({log(y)}, Reals))
+
+ When does exp(x) == 1?
+
+ >>> invert_complex(exp(x), 1, x)
+ (x, ImageSet(Lambda(_n, 2*_n*I*pi), Integers))
+ >>> invert_real(exp(x), 1, x)
+ (x, {0})
+
+ See Also
+ ========
+ invert_real, invert_complex
+ """
+ x = sympify(x)
+ if not x.is_Symbol:
+ raise ValueError("x must be a symbol")
+ f_x = sympify(f_x)
+ if x not in f_x.free_symbols:
+ raise ValueError("Inverse of constant function doesn't exist")
+ y = sympify(y)
+ if x in y.free_symbols:
+ raise ValueError("y should be independent of x ")
+
+ if domain.is_subset(S.Reals):
+ x1, s = _invert_real(f_x, FiniteSet(y), x)
+ else:
+ x1, s = _invert_complex(f_x, FiniteSet(y), x)
+
+ if not isinstance(s, FiniteSet) or x1 != x:
+ return x1, s
+
+ # Avoid adding gratuitous intersections with S.Complexes. Actual
+ # conditions should be handled by the respective inverters.
+ if domain is S.Complexes:
+ return x1, s
+ else:
+ return x1, s.intersection(domain)
+
+
+invert_complex = _invert
+
+
+def invert_real(f_x, y, x):
+ """
+ Inverts a real-valued function. Same as :func:`invert_complex`, but sets
+ the domain to ``S.Reals`` before inverting.
+ """
+ return _invert(f_x, y, x, S.Reals)
+
+
+def _invert_real(f, g_ys, symbol):
+ """Helper function for _invert."""
+
+ if f == symbol or g_ys is S.EmptySet:
+ return (f, g_ys)
+
+ n = Dummy('n', real=True)
+
+ if isinstance(f, exp) or (f.is_Pow and f.base == S.Exp1):
+ return _invert_real(f.exp,
+ imageset(Lambda(n, log(n)), g_ys),
+ symbol)
+
+ if hasattr(f, 'inverse') and f.inverse() is not None and not isinstance(f, (
+ TrigonometricFunction,
+ HyperbolicFunction,
+ )):
+ if len(f.args) > 1:
+ raise ValueError("Only functions with one argument are supported.")
+ return _invert_real(f.args[0],
+ imageset(Lambda(n, f.inverse()(n)), g_ys),
+ symbol)
+
+ if isinstance(f, Abs):
+ return _invert_abs(f.args[0], g_ys, symbol)
+
+ if f.is_Add:
+ # f = g + h
+ g, h = f.as_independent(symbol)
+ if g is not S.Zero:
+ return _invert_real(h, imageset(Lambda(n, n - g), g_ys), symbol)
+
+ if f.is_Mul:
+ # f = g*h
+ g, h = f.as_independent(symbol)
+
+ if g is not S.One:
+ return _invert_real(h, imageset(Lambda(n, n/g), g_ys), symbol)
+
+ if f.is_Pow:
+ base, expo = f.args
+ base_has_sym = base.has(symbol)
+ expo_has_sym = expo.has(symbol)
+
+ if not expo_has_sym:
+
+ if expo.is_rational:
+ num, den = expo.as_numer_denom()
+
+ if den % 2 == 0 and num % 2 == 1 and den.is_zero is False:
+ # Here we have f(x)**(num/den) = y
+ # where den is nonzero and even and y is an element
+ # of the set g_ys.
+ # den is even, so we are only interested in the cases
+ # where both f(x) and y are positive.
+ # Restricting y to be positive (using the set g_ys_pos)
+ # means that y**(den/num) is always positive.
+ # Therefore it isn't necessary to also constrain f(x)
+ # to be positive because we are only going to
+ # find solutions of f(x) = y**(d/n)
+ # where the rhs is already required to be positive.
+ root = Lambda(n, real_root(n, expo))
+ g_ys_pos = g_ys & Interval(0, oo)
+ res = imageset(root, g_ys_pos)
+ _inv, _set = _invert_real(base, res, symbol)
+ return (_inv, _set)
+
+ if den % 2 == 1:
+ root = Lambda(n, real_root(n, expo))
+ res = imageset(root, g_ys)
+ if num % 2 == 0:
+ neg_res = imageset(Lambda(n, -n), res)
+ return _invert_real(base, res + neg_res, symbol)
+ if num % 2 == 1:
+ return _invert_real(base, res, symbol)
+
+ elif expo.is_irrational:
+ root = Lambda(n, real_root(n, expo))
+ g_ys_pos = g_ys & Interval(0, oo)
+ res = imageset(root, g_ys_pos)
+ return _invert_real(base, res, symbol)
+
+ else:
+ # indeterminate exponent, e.g. Float or parity of
+ # num, den of rational could not be determined
+ pass # use default return
+
+ if not base_has_sym:
+ rhs = g_ys.args[0]
+ if base.is_positive:
+ return _invert_real(expo,
+ imageset(Lambda(n, log(n, base, evaluate=False)), g_ys), symbol)
+ elif base.is_negative:
+ s, b = integer_log(rhs, base)
+ if b:
+ return _invert_real(expo, FiniteSet(s), symbol)
+ else:
+ return (expo, S.EmptySet)
+ elif base.is_zero:
+ one = Eq(rhs, 1)
+ if one == S.true:
+ # special case: 0**x - 1
+ return _invert_real(expo, FiniteSet(0), symbol)
+ elif one == S.false:
+ return (expo, S.EmptySet)
+
+
+ if isinstance(f, TrigonometricFunction):
+ if isinstance(g_ys, FiniteSet):
+ def inv(trig):
+ if isinstance(trig, (sin, csc)):
+ F = asin if isinstance(trig, sin) else acsc
+ return (lambda a: n*pi + S.NegativeOne**n*F(a),)
+ if isinstance(trig, (cos, sec)):
+ F = acos if isinstance(trig, cos) else asec
+ return (
+ lambda a: 2*n*pi + F(a),
+ lambda a: 2*n*pi - F(a),)
+ if isinstance(trig, (tan, cot)):
+ return (lambda a: n*pi + trig.inverse()(a),)
+
+ n = Dummy('n', integer=True)
+ invs = S.EmptySet
+ for L in inv(f):
+ invs += Union(*[imageset(Lambda(n, L(g)), S.Integers) for g in g_ys])
+ return _invert_real(f.args[0], invs, symbol)
+
+ return (f, g_ys)
+
+
+def _invert_complex(f, g_ys, symbol):
+ """Helper function for _invert."""
+
+ if f == symbol or g_ys is S.EmptySet:
+ return (f, g_ys)
+
+ n = Dummy('n')
+
+ if f.is_Add:
+ # f = g + h
+ g, h = f.as_independent(symbol)
+ if g is not S.Zero:
+ return _invert_complex(h, imageset(Lambda(n, n - g), g_ys), symbol)
+
+ if f.is_Mul:
+ # f = g*h
+ g, h = f.as_independent(symbol)
+
+ if g is not S.One:
+ if g in {S.NegativeInfinity, S.ComplexInfinity, S.Infinity}:
+ return (h, S.EmptySet)
+ return _invert_complex(h, imageset(Lambda(n, n/g), g_ys), symbol)
+
+ if f.is_Pow:
+ base, expo = f.args
+ # special case: g**r = 0
+ # Could be improved like `_invert_real` to handle more general cases.
+ if expo.is_Rational and g_ys == FiniteSet(0):
+ if expo.is_positive:
+ return _invert_complex(base, g_ys, symbol)
+
+ if hasattr(f, 'inverse') and f.inverse() is not None and \
+ not isinstance(f, TrigonometricFunction) and \
+ not isinstance(f, HyperbolicFunction) and \
+ not isinstance(f, exp):
+ if len(f.args) > 1:
+ raise ValueError("Only functions with one argument are supported.")
+ return _invert_complex(f.args[0],
+ imageset(Lambda(n, f.inverse()(n)), g_ys), symbol)
+
+ if isinstance(f, exp) or (f.is_Pow and f.base == S.Exp1):
+ if isinstance(g_ys, ImageSet):
+ # can solve upto `(d*exp(exp(...(exp(a*x + b))...) + c)` format.
+ # Further can be improved to `(d*exp(exp(...(exp(a*x**n + b*x**(n-1) + ... + f))...) + c)`.
+ g_ys_expr = g_ys.lamda.expr
+ g_ys_vars = g_ys.lamda.variables
+ k = Dummy('k{}'.format(len(g_ys_vars)))
+ g_ys_vars_1 = (k,) + g_ys_vars
+ exp_invs = Union(*[imageset(Lambda((g_ys_vars_1,), (I*(2*k*pi + arg(g_ys_expr))
+ + log(Abs(g_ys_expr)))), S.Integers**(len(g_ys_vars_1)))])
+ return _invert_complex(f.exp, exp_invs, symbol)
+
+ elif isinstance(g_ys, FiniteSet):
+ exp_invs = Union(*[imageset(Lambda(n, I*(2*n*pi + arg(g_y)) +
+ log(Abs(g_y))), S.Integers)
+ for g_y in g_ys if g_y != 0])
+ return _invert_complex(f.exp, exp_invs, symbol)
+
+ return (f, g_ys)
+
+
+def _invert_abs(f, g_ys, symbol):
+ """Helper function for inverting absolute value functions.
+
+ Returns the complete result of inverting an absolute value
+ function along with the conditions which must also be satisfied.
+
+ If it is certain that all these conditions are met, a :class:`~.FiniteSet`
+ of all possible solutions is returned. If any condition cannot be
+ satisfied, an :class:`~.EmptySet` is returned. Otherwise, a
+ :class:`~.ConditionSet` of the solutions, with all the required conditions
+ specified, is returned.
+
+ """
+ if not g_ys.is_FiniteSet:
+ # this could be used for FiniteSet, but the
+ # results are more compact if they aren't, e.g.
+ # ConditionSet(x, Contains(n, Interval(0, oo)), {-n, n}) vs
+ # Union(Intersection(Interval(0, oo), {n}), Intersection(Interval(-oo, 0), {-n}))
+ # for the solution of abs(x) - n
+ pos = Intersection(g_ys, Interval(0, S.Infinity))
+ parg = _invert_real(f, pos, symbol)
+ narg = _invert_real(-f, pos, symbol)
+ if parg[0] != narg[0]:
+ raise NotImplementedError
+ return parg[0], Union(narg[1], parg[1])
+
+ # check conditions: all these must be true. If any are unknown
+ # then return them as conditions which must be satisfied
+ unknown = []
+ for a in g_ys.args:
+ ok = a.is_nonnegative if a.is_Number else a.is_positive
+ if ok is None:
+ unknown.append(a)
+ elif not ok:
+ return symbol, S.EmptySet
+ if unknown:
+ conditions = And(*[Contains(i, Interval(0, oo))
+ for i in unknown])
+ else:
+ conditions = True
+ n = Dummy('n', real=True)
+ # this is slightly different than above: instead of solving
+ # +/-f on positive values, here we solve for f on +/- g_ys
+ g_x, values = _invert_real(f, Union(
+ imageset(Lambda(n, n), g_ys),
+ imageset(Lambda(n, -n), g_ys)), symbol)
+ return g_x, ConditionSet(g_x, conditions, values)
+
+
+def domain_check(f, symbol, p):
+ """Returns False if point p is infinite or any subexpression of f
+ is infinite or becomes so after replacing symbol with p. If none of
+ these conditions is met then True will be returned.
+
+ Examples
+ ========
+
+ >>> from sympy import Mul, oo
+ >>> from sympy.abc import x
+ >>> from sympy.solvers.solveset import domain_check
+ >>> g = 1/(1 + (1/(x + 1))**2)
+ >>> domain_check(g, x, -1)
+ False
+ >>> domain_check(x**2, x, 0)
+ True
+ >>> domain_check(1/x, x, oo)
+ False
+
+ * The function relies on the assumption that the original form
+ of the equation has not been changed by automatic simplification.
+
+ >>> domain_check(x/x, x, 0) # x/x is automatically simplified to 1
+ True
+
+ * To deal with automatic evaluations use evaluate=False:
+
+ >>> domain_check(Mul(x, 1/x, evaluate=False), x, 0)
+ False
+ """
+ f, p = sympify(f), sympify(p)
+ if p.is_infinite:
+ return False
+ return _domain_check(f, symbol, p)
+
+
+def _domain_check(f, symbol, p):
+ # helper for domain check
+ if f.is_Atom and f.is_finite:
+ return True
+ elif f.subs(symbol, p).is_infinite:
+ return False
+ elif isinstance(f, Piecewise):
+ # Check the cases of the Piecewise in turn. There might be invalid
+ # expressions in later cases that don't apply e.g.
+ # solveset(Piecewise((0, Eq(x, 0)), (1/x, True)), x)
+ for expr, cond in f.args:
+ condsubs = cond.subs(symbol, p)
+ if condsubs is S.false:
+ continue
+ elif condsubs is S.true:
+ return _domain_check(expr, symbol, p)
+ else:
+ # We don't know which case of the Piecewise holds. On this
+ # basis we cannot decide whether any solution is in or out of
+ # the domain. Ideally this function would allow returning a
+ # symbolic condition for the validity of the solution that
+ # could be handled in the calling code. In the mean time we'll
+ # give this particular solution the benefit of the doubt and
+ # let it pass.
+ return True
+ else:
+ # TODO : We should not blindly recurse through all args of arbitrary expressions like this
+ return all(_domain_check(g, symbol, p)
+ for g in f.args)
+
+
+def _is_finite_with_finite_vars(f, domain=S.Complexes):
+ """
+ Return True if the given expression is finite. For symbols that
+ do not assign a value for `complex` and/or `real`, the domain will
+ be used to assign a value; symbols that do not assign a value
+ for `finite` will be made finite. All other assumptions are
+ left unmodified.
+ """
+ def assumptions(s):
+ A = s.assumptions0
+ A.setdefault('finite', A.get('finite', True))
+ if domain.is_subset(S.Reals):
+ # if this gets set it will make complex=True, too
+ A.setdefault('real', True)
+ else:
+ # don't change 'real' because being complex implies
+ # nothing about being real
+ A.setdefault('complex', True)
+ return A
+
+ reps = {s: Dummy(**assumptions(s)) for s in f.free_symbols}
+ return f.xreplace(reps).is_finite
+
+
+def _is_function_class_equation(func_class, f, symbol):
+ """ Tests whether the equation is an equation of the given function class.
+
+ The given equation belongs to the given function class if it is
+ comprised of functions of the function class which are multiplied by
+ or added to expressions independent of the symbol. In addition, the
+ arguments of all such functions must be linear in the symbol as well.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.solveset import _is_function_class_equation
+ >>> from sympy import tan, sin, tanh, sinh, exp
+ >>> from sympy.abc import x
+ >>> from sympy.functions.elementary.trigonometric import TrigonometricFunction
+ >>> from sympy.functions.elementary.hyperbolic import HyperbolicFunction
+ >>> _is_function_class_equation(TrigonometricFunction, exp(x) + tan(x), x)
+ False
+ >>> _is_function_class_equation(TrigonometricFunction, tan(x) + sin(x), x)
+ True
+ >>> _is_function_class_equation(TrigonometricFunction, tan(x**2), x)
+ False
+ >>> _is_function_class_equation(TrigonometricFunction, tan(x + 2), x)
+ True
+ >>> _is_function_class_equation(HyperbolicFunction, tanh(x) + sinh(x), x)
+ True
+ """
+ if f.is_Mul or f.is_Add:
+ return all(_is_function_class_equation(func_class, arg, symbol)
+ for arg in f.args)
+
+ if f.is_Pow:
+ if not f.exp.has(symbol):
+ return _is_function_class_equation(func_class, f.base, symbol)
+ else:
+ return False
+
+ if not f.has(symbol):
+ return True
+
+ if isinstance(f, func_class):
+ try:
+ g = Poly(f.args[0], symbol)
+ return g.degree() <= 1
+ except PolynomialError:
+ return False
+ else:
+ return False
+
+
+def _solve_as_rational(f, symbol, domain):
+ """ solve rational functions"""
+ f = together(_mexpand(f, recursive=True), deep=True)
+ g, h = fraction(f)
+ if not h.has(symbol):
+ try:
+ return _solve_as_poly(g, symbol, domain)
+ except NotImplementedError:
+ # The polynomial formed from g could end up having
+ # coefficients in a ring over which finding roots
+ # isn't implemented yet, e.g. ZZ[a] for some symbol a
+ return ConditionSet(symbol, Eq(f, 0), domain)
+ except CoercionFailed:
+ # contained oo, zoo or nan
+ return S.EmptySet
+ else:
+ valid_solns = _solveset(g, symbol, domain)
+ invalid_solns = _solveset(h, symbol, domain)
+ return valid_solns - invalid_solns
+
+
+class _SolveTrig1Error(Exception):
+ """Raised when _solve_trig1 heuristics do not apply"""
+
+def _solve_trig(f, symbol, domain):
+ """Function to call other helpers to solve trigonometric equations """
+ sol = None
+ try:
+ sol = _solve_trig1(f, symbol, domain)
+ except _SolveTrig1Error:
+ try:
+ sol = _solve_trig2(f, symbol, domain)
+ except ValueError:
+ raise NotImplementedError(filldedent('''
+ Solution to this kind of trigonometric equations
+ is yet to be implemented'''))
+ return sol
+
+
+def _solve_trig1(f, symbol, domain):
+ """Primary solver for trigonometric and hyperbolic equations
+
+ Returns either the solution set as a ConditionSet (auto-evaluated to a
+ union of ImageSets if no variables besides 'symbol' are involved) or
+ raises _SolveTrig1Error if f == 0 cannot be solved.
+
+ Notes
+ =====
+ Algorithm:
+ 1. Do a change of variable x -> mu*x in arguments to trigonometric and
+ hyperbolic functions, in order to reduce them to small integers. (This
+ step is crucial to keep the degrees of the polynomials of step 4 low.)
+ 2. Rewrite trigonometric/hyperbolic functions as exponentials.
+ 3. Proceed to a 2nd change of variable, replacing exp(I*x) or exp(x) by y.
+ 4. Solve the resulting rational equation.
+ 5. Use invert_complex or invert_real to return to the original variable.
+ 6. If the coefficients of 'symbol' were symbolic in nature, add the
+ necessary consistency conditions in a ConditionSet.
+
+ """
+ # Prepare change of variable
+ x = Dummy('x')
+ if _is_function_class_equation(HyperbolicFunction, f, symbol):
+ cov = exp(x)
+ inverter = invert_real if domain.is_subset(S.Reals) else invert_complex
+ else:
+ cov = exp(I*x)
+ inverter = invert_complex
+
+ f = trigsimp(f)
+ f_original = f
+ trig_functions = f.atoms(TrigonometricFunction, HyperbolicFunction)
+ trig_arguments = [e.args[0] for e in trig_functions]
+ # trigsimp may have reduced the equation to an expression
+ # that is independent of 'symbol' (e.g. cos**2+sin**2)
+ if not any(a.has(symbol) for a in trig_arguments):
+ return solveset(f_original, symbol, domain)
+
+ denominators = []
+ numerators = []
+ for ar in trig_arguments:
+ try:
+ poly_ar = Poly(ar, symbol)
+ except PolynomialError:
+ raise _SolveTrig1Error("trig argument is not a polynomial")
+ if poly_ar.degree() > 1: # degree >1 still bad
+ raise _SolveTrig1Error("degree of variable must not exceed one")
+ if poly_ar.degree() == 0: # degree 0, don't care
+ continue
+ c = poly_ar.all_coeffs()[0] # got the coefficient of 'symbol'
+ numerators.append(fraction(c)[0])
+ denominators.append(fraction(c)[1])
+
+ mu = lcm(denominators)/gcd(numerators)
+ f = f.subs(symbol, mu*x)
+ f = f.rewrite(exp)
+ f = together(f)
+ g, h = fraction(f)
+ y = Dummy('y')
+ g, h = g.expand(), h.expand()
+ g, h = g.subs(cov, y), h.subs(cov, y)
+ if g.has(x) or h.has(x):
+ raise _SolveTrig1Error("change of variable not possible")
+
+ solns = solveset_complex(g, y) - solveset_complex(h, y)
+ if isinstance(solns, ConditionSet):
+ raise _SolveTrig1Error("polynomial has ConditionSet solution")
+
+ if isinstance(solns, FiniteSet):
+ if any(isinstance(s, RootOf) for s in solns):
+ raise _SolveTrig1Error("polynomial results in RootOf object")
+ # revert the change of variable
+ cov = cov.subs(x, symbol/mu)
+ result = Union(*[inverter(cov, s, symbol)[1] for s in solns])
+ # In case of symbolic coefficients, the solution set is only valid
+ # if numerator and denominator of mu are non-zero.
+ if mu.has(Symbol):
+ syms = (mu).atoms(Symbol)
+ munum, muden = fraction(mu)
+ condnum = munum.as_independent(*syms, as_Add=False)[1]
+ condden = muden.as_independent(*syms, as_Add=False)[1]
+ cond = And(Ne(condnum, 0), Ne(condden, 0))
+ else:
+ cond = True
+ # Actual conditions are returned as part of the ConditionSet. Adding an
+ # intersection with C would only complicate some solution sets due to
+ # current limitations of intersection code. (e.g. #19154)
+ if domain is S.Complexes:
+ # This is a slight abuse of ConditionSet. Ideally this should
+ # be some kind of "PiecewiseSet". (See #19507 discussion)
+ return ConditionSet(symbol, cond, result)
+ else:
+ return ConditionSet(symbol, cond, Intersection(result, domain))
+ elif solns is S.EmptySet:
+ return S.EmptySet
+ else:
+ raise _SolveTrig1Error("polynomial solutions must form FiniteSet")
+
+
+def _solve_trig2(f, symbol, domain):
+ """Secondary helper to solve trigonometric equations,
+ called when first helper fails """
+ f = trigsimp(f)
+ f_original = f
+ trig_functions = f.atoms(sin, cos, tan, sec, cot, csc)
+ trig_arguments = [e.args[0] for e in trig_functions]
+ denominators = []
+ numerators = []
+
+ # todo: This solver can be extended to hyperbolics if the
+ # analogous change of variable to tanh (instead of tan)
+ # is used.
+ if not trig_functions:
+ return ConditionSet(symbol, Eq(f_original, 0), domain)
+
+ # todo: The pre-processing below (extraction of numerators, denominators,
+ # gcd, lcm, mu, etc.) should be updated to the enhanced version in
+ # _solve_trig1. (See #19507)
+ for ar in trig_arguments:
+ try:
+ poly_ar = Poly(ar, symbol)
+ except PolynomialError:
+ raise ValueError("give up, we cannot solve if this is not a polynomial in x")
+ if poly_ar.degree() > 1: # degree >1 still bad
+ raise ValueError("degree of variable inside polynomial should not exceed one")
+ if poly_ar.degree() == 0: # degree 0, don't care
+ continue
+ c = poly_ar.all_coeffs()[0] # got the coefficient of 'symbol'
+ try:
+ numerators.append(Rational(c).p)
+ denominators.append(Rational(c).q)
+ except TypeError:
+ return ConditionSet(symbol, Eq(f_original, 0), domain)
+
+ x = Dummy('x')
+
+ # ilcm() and igcd() require more than one argument
+ if len(numerators) > 1:
+ mu = Rational(2)*ilcm(*denominators)/igcd(*numerators)
+ else:
+ assert len(numerators) == 1
+ mu = Rational(2)*denominators[0]/numerators[0]
+
+ f = f.subs(symbol, mu*x)
+ f = f.rewrite(tan)
+ f = expand_trig(f)
+ f = together(f)
+
+ g, h = fraction(f)
+ y = Dummy('y')
+ g, h = g.expand(), h.expand()
+ g, h = g.subs(tan(x), y), h.subs(tan(x), y)
+
+ if g.has(x) or h.has(x):
+ return ConditionSet(symbol, Eq(f_original, 0), domain)
+ solns = solveset(g, y, S.Reals) - solveset(h, y, S.Reals)
+
+ if isinstance(solns, FiniteSet):
+ result = Union(*[invert_real(tan(symbol/mu), s, symbol)[1]
+ for s in solns])
+ dsol = invert_real(tan(symbol/mu), oo, symbol)[1]
+ if degree(h) > degree(g): # If degree(denom)>degree(num) then there
+ result = Union(result, dsol) # would be another sol at Lim(denom-->oo)
+ return Intersection(result, domain)
+ elif solns is S.EmptySet:
+ return S.EmptySet
+ else:
+ return ConditionSet(symbol, Eq(f_original, 0), S.Reals)
+
+
+def _solve_as_poly(f, symbol, domain=S.Complexes):
+ """
+ Solve the equation using polynomial techniques if it already is a
+ polynomial equation or, with a change of variables, can be made so.
+ """
+ result = None
+ if f.is_polynomial(symbol):
+ solns = roots(f, symbol, cubics=True, quartics=True,
+ quintics=True, domain='EX')
+ num_roots = sum(solns.values())
+ if degree(f, symbol) <= num_roots:
+ result = FiniteSet(*solns.keys())
+ else:
+ poly = Poly(f, symbol)
+ solns = poly.all_roots()
+ if poly.degree() <= len(solns):
+ result = FiniteSet(*solns)
+ else:
+ result = ConditionSet(symbol, Eq(f, 0), domain)
+ else:
+ poly = Poly(f)
+ if poly is None:
+ result = ConditionSet(symbol, Eq(f, 0), domain)
+ gens = [g for g in poly.gens if g.has(symbol)]
+
+ if len(gens) == 1:
+ poly = Poly(poly, gens[0])
+ gen = poly.gen
+ deg = poly.degree()
+ poly = Poly(poly.as_expr(), poly.gen, composite=True)
+ poly_solns = FiniteSet(*roots(poly, cubics=True, quartics=True,
+ quintics=True).keys())
+
+ if len(poly_solns) < deg:
+ result = ConditionSet(symbol, Eq(f, 0), domain)
+
+ if gen != symbol:
+ y = Dummy('y')
+ inverter = invert_real if domain.is_subset(S.Reals) else invert_complex
+ lhs, rhs_s = inverter(gen, y, symbol)
+ if lhs == symbol:
+ result = Union(*[rhs_s.subs(y, s) for s in poly_solns])
+ if isinstance(result, FiniteSet) and isinstance(gen, Pow
+ ) and gen.base.is_Rational:
+ result = FiniteSet(*[expand_log(i) for i in result])
+ else:
+ result = ConditionSet(symbol, Eq(f, 0), domain)
+ else:
+ result = ConditionSet(symbol, Eq(f, 0), domain)
+
+ if result is not None:
+ if isinstance(result, FiniteSet):
+ # this is to simplify solutions like -sqrt(-I) to sqrt(2)/2
+ # - sqrt(2)*I/2. We are not expanding for solution with symbols
+ # or undefined functions because that makes the solution more complicated.
+ # For example, expand_complex(a) returns re(a) + I*im(a)
+ if all(s.atoms(Symbol, AppliedUndef) == set() and not isinstance(s, RootOf)
+ for s in result):
+ s = Dummy('s')
+ result = imageset(Lambda(s, expand_complex(s)), result)
+ if isinstance(result, FiniteSet) and domain != S.Complexes:
+ # Avoid adding gratuitous intersections with S.Complexes. Actual
+ # conditions should be handled elsewhere.
+ result = result.intersection(domain)
+ return result
+ else:
+ return ConditionSet(symbol, Eq(f, 0), domain)
+
+
+def _solve_radical(f, unradf, symbol, solveset_solver):
+ """ Helper function to solve equations with radicals """
+ res = unradf
+ eq, cov = res if res else (f, [])
+ if not cov:
+ result = solveset_solver(eq, symbol) - \
+ Union(*[solveset_solver(g, symbol) for g in denoms(f, symbol)])
+ else:
+ y, yeq = cov
+ if not solveset_solver(y - I, y):
+ yreal = Dummy('yreal', real=True)
+ yeq = yeq.xreplace({y: yreal})
+ eq = eq.xreplace({y: yreal})
+ y = yreal
+ g_y_s = solveset_solver(yeq, symbol)
+ f_y_sols = solveset_solver(eq, y)
+ result = Union(*[imageset(Lambda(y, g_y), f_y_sols)
+ for g_y in g_y_s])
+
+ def check_finiteset(solutions):
+ f_set = [] # solutions for FiniteSet
+ c_set = [] # solutions for ConditionSet
+ for s in solutions:
+ if checksol(f, symbol, s):
+ f_set.append(s)
+ else:
+ c_set.append(s)
+ return FiniteSet(*f_set) + ConditionSet(symbol, Eq(f, 0), FiniteSet(*c_set))
+
+ def check_set(solutions):
+ if solutions is S.EmptySet:
+ return solutions
+ elif isinstance(solutions, ConditionSet):
+ # XXX: Maybe the base set should be checked?
+ return solutions
+ elif isinstance(solutions, FiniteSet):
+ return check_finiteset(solutions)
+ elif isinstance(solutions, Complement):
+ A, B = solutions.args
+ return Complement(check_set(A), B)
+ elif isinstance(solutions, Union):
+ return Union(*[check_set(s) for s in solutions.args])
+ else:
+ # XXX: There should be more cases checked here. The cases above
+ # are all those that come up in the test suite for now.
+ return solutions
+
+ solution_set = check_set(result)
+
+ return solution_set
+
+
+def _solve_abs(f, symbol, domain):
+ """ Helper function to solve equation involving absolute value function """
+ if not domain.is_subset(S.Reals):
+ raise ValueError(filldedent('''
+ Absolute values cannot be inverted in the
+ complex domain.'''))
+ p, q, r = Wild('p'), Wild('q'), Wild('r')
+ pattern_match = f.match(p*Abs(q) + r) or {}
+ f_p, f_q, f_r = [pattern_match.get(i, S.Zero) for i in (p, q, r)]
+
+ if not (f_p.is_zero or f_q.is_zero):
+ domain = continuous_domain(f_q, symbol, domain)
+ from .inequalities import solve_univariate_inequality
+ q_pos_cond = solve_univariate_inequality(f_q >= 0, symbol,
+ relational=False, domain=domain, continuous=True)
+ q_neg_cond = q_pos_cond.complement(domain)
+
+ sols_q_pos = solveset_real(f_p*f_q + f_r,
+ symbol).intersect(q_pos_cond)
+ sols_q_neg = solveset_real(f_p*(-f_q) + f_r,
+ symbol).intersect(q_neg_cond)
+ return Union(sols_q_pos, sols_q_neg)
+ else:
+ return ConditionSet(symbol, Eq(f, 0), domain)
+
+
+def solve_decomposition(f, symbol, domain):
+ """
+ Function to solve equations via the principle of "Decomposition
+ and Rewriting".
+
+ Examples
+ ========
+ >>> from sympy import exp, sin, Symbol, pprint, S
+ >>> from sympy.solvers.solveset import solve_decomposition as sd
+ >>> x = Symbol('x')
+ >>> f1 = exp(2*x) - 3*exp(x) + 2
+ >>> sd(f1, x, S.Reals)
+ {0, log(2)}
+ >>> f2 = sin(x)**2 + 2*sin(x) + 1
+ >>> pprint(sd(f2, x, S.Reals), use_unicode=False)
+ 3*pi
+ {2*n*pi + ---- | n in Integers}
+ 2
+ >>> f3 = sin(x + 2)
+ >>> pprint(sd(f3, x, S.Reals), use_unicode=False)
+ {2*n*pi - 2 | n in Integers} U {2*n*pi - 2 + pi | n in Integers}
+
+ """
+ from sympy.solvers.decompogen import decompogen
+ # decompose the given function
+ g_s = decompogen(f, symbol)
+ # `y_s` represents the set of values for which the function `g` is to be
+ # solved.
+ # `solutions` represent the solutions of the equations `g = y_s` or
+ # `g = 0` depending on the type of `y_s`.
+ # As we are interested in solving the equation: f = 0
+ y_s = FiniteSet(0)
+ for g in g_s:
+ frange = function_range(g, symbol, domain)
+ y_s = Intersection(frange, y_s)
+ result = S.EmptySet
+ if isinstance(y_s, FiniteSet):
+ for y in y_s:
+ solutions = solveset(Eq(g, y), symbol, domain)
+ if not isinstance(solutions, ConditionSet):
+ result += solutions
+
+ else:
+ if isinstance(y_s, ImageSet):
+ iter_iset = (y_s,)
+
+ elif isinstance(y_s, Union):
+ iter_iset = y_s.args
+
+ elif y_s is S.EmptySet:
+ # y_s is not in the range of g in g_s, so no solution exists
+ #in the given domain
+ return S.EmptySet
+
+ for iset in iter_iset:
+ new_solutions = solveset(Eq(iset.lamda.expr, g), symbol, domain)
+ dummy_var = tuple(iset.lamda.expr.free_symbols)[0]
+ (base_set,) = iset.base_sets
+ if isinstance(new_solutions, FiniteSet):
+ new_exprs = new_solutions
+
+ elif isinstance(new_solutions, Intersection):
+ if isinstance(new_solutions.args[1], FiniteSet):
+ new_exprs = new_solutions.args[1]
+
+ for new_expr in new_exprs:
+ result += ImageSet(Lambda(dummy_var, new_expr), base_set)
+
+ if result is S.EmptySet:
+ return ConditionSet(symbol, Eq(f, 0), domain)
+
+ y_s = result
+
+ return y_s
+
+
+def _solveset(f, symbol, domain, _check=False):
+ """Helper for solveset to return a result from an expression
+ that has already been sympify'ed and is known to contain the
+ given symbol."""
+ # _check controls whether the answer is checked or not
+ from sympy.simplify.simplify import signsimp
+
+ if isinstance(f, BooleanTrue):
+ return domain
+
+ orig_f = f
+ if f.is_Mul:
+ coeff, f = f.as_independent(symbol, as_Add=False)
+ if coeff in {S.ComplexInfinity, S.NegativeInfinity, S.Infinity}:
+ f = together(orig_f)
+ elif f.is_Add:
+ a, h = f.as_independent(symbol)
+ m, h = h.as_independent(symbol, as_Add=False)
+ if m not in {S.ComplexInfinity, S.Zero, S.Infinity,
+ S.NegativeInfinity}:
+ f = a/m + h # XXX condition `m != 0` should be added to soln
+
+ # assign the solvers to use
+ solver = lambda f, x, domain=domain: _solveset(f, x, domain)
+ inverter = lambda f, rhs, symbol: _invert(f, rhs, symbol, domain)
+
+ result = S.EmptySet
+
+ if f.expand().is_zero:
+ return domain
+ elif not f.has(symbol):
+ return S.EmptySet
+ elif f.is_Mul and all(_is_finite_with_finite_vars(m, domain)
+ for m in f.args):
+ # if f(x) and g(x) are both finite we can say that the solution of
+ # f(x)*g(x) == 0 is same as Union(f(x) == 0, g(x) == 0) is not true in
+ # general. g(x) can grow to infinitely large for the values where
+ # f(x) == 0. To be sure that we are not silently allowing any
+ # wrong solutions we are using this technique only if both f and g are
+ # finite for a finite input.
+ result = Union(*[solver(m, symbol) for m in f.args])
+ elif _is_function_class_equation(TrigonometricFunction, f, symbol) or \
+ _is_function_class_equation(HyperbolicFunction, f, symbol):
+ result = _solve_trig(f, symbol, domain)
+ elif isinstance(f, arg):
+ a = f.args[0]
+ result = Intersection(_solveset(re(a) > 0, symbol, domain),
+ _solveset(im(a), symbol, domain))
+ elif f.is_Piecewise:
+ expr_set_pairs = f.as_expr_set_pairs(domain)
+ for (expr, in_set) in expr_set_pairs:
+ if in_set.is_Relational:
+ in_set = in_set.as_set()
+ solns = solver(expr, symbol, in_set)
+ result += solns
+ elif isinstance(f, Eq):
+ result = solver(Add(f.lhs, - f.rhs, evaluate=False), symbol, domain)
+
+ elif f.is_Relational:
+ from .inequalities import solve_univariate_inequality
+ try:
+ result = solve_univariate_inequality(
+ f, symbol, domain=domain, relational=False)
+ except NotImplementedError:
+ result = ConditionSet(symbol, f, domain)
+ return result
+ elif _is_modular(f, symbol):
+ result = _solve_modular(f, symbol, domain)
+ else:
+ lhs, rhs_s = inverter(f, 0, symbol)
+ if lhs == symbol:
+ # do some very minimal simplification since
+ # repeated inversion may have left the result
+ # in a state that other solvers (e.g. poly)
+ # would have simplified; this is done here
+ # rather than in the inverter since here it
+ # is only done once whereas there it would
+ # be repeated for each step of the inversion
+ if isinstance(rhs_s, FiniteSet):
+ rhs_s = FiniteSet(*[Mul(*
+ signsimp(i).as_content_primitive())
+ for i in rhs_s])
+ result = rhs_s
+
+ elif isinstance(rhs_s, FiniteSet):
+ for equation in [lhs - rhs for rhs in rhs_s]:
+ if equation == f:
+ u = unrad(f, symbol)
+ if u:
+ result += _solve_radical(equation, u,
+ symbol,
+ solver)
+ elif equation.has(Abs):
+ result += _solve_abs(f, symbol, domain)
+ else:
+ result_rational = _solve_as_rational(equation, symbol, domain)
+ if not isinstance(result_rational, ConditionSet):
+ result += result_rational
+ else:
+ # may be a transcendental type equation
+ t_result = _transolve(equation, symbol, domain)
+ if isinstance(t_result, ConditionSet):
+ # might need factoring; this is expensive so we
+ # have delayed until now. To avoid recursion
+ # errors look for a non-trivial factoring into
+ # a product of symbol dependent terms; I think
+ # that something that factors as a Pow would
+ # have already been recognized by now.
+ factored = equation.factor()
+ if factored.is_Mul and equation != factored:
+ _, dep = factored.as_independent(symbol)
+ if not dep.is_Add:
+ # non-trivial factoring of equation
+ # but use form with constants
+ # in case they need special handling
+ t_results = []
+ for fac in Mul.make_args(factored):
+ if fac.has(symbol):
+ t_results.append(solver(fac, symbol))
+ t_result = Union(*t_results)
+ result += t_result
+ else:
+ result += solver(equation, symbol)
+
+ elif rhs_s is not S.EmptySet:
+ result = ConditionSet(symbol, Eq(f, 0), domain)
+
+ if isinstance(result, ConditionSet):
+ if isinstance(f, Expr):
+ num, den = f.as_numer_denom()
+ if den.has(symbol):
+ _result = _solveset(num, symbol, domain)
+ if not isinstance(_result, ConditionSet):
+ singularities = _solveset(den, symbol, domain)
+ result = _result - singularities
+
+ if _check:
+ if isinstance(result, ConditionSet):
+ # it wasn't solved or has enumerated all conditions
+ # -- leave it alone
+ return result
+
+ # whittle away all but the symbol-containing core
+ # to use this for testing
+ if isinstance(orig_f, Expr):
+ fx = orig_f.as_independent(symbol, as_Add=True)[1]
+ fx = fx.as_independent(symbol, as_Add=False)[1]
+ else:
+ fx = orig_f
+
+ if isinstance(result, FiniteSet):
+ # check the result for invalid solutions
+ result = FiniteSet(*[s for s in result
+ if isinstance(s, RootOf)
+ or domain_check(fx, symbol, s)])
+
+ return result
+
+
+def _is_modular(f, symbol):
+ """
+ Helper function to check below mentioned types of modular equations.
+ ``A - Mod(B, C) = 0``
+
+ A -> This can or cannot be a function of symbol.
+ B -> This is surely a function of symbol.
+ C -> It is an integer.
+
+ Parameters
+ ==========
+
+ f : Expr
+ The equation to be checked.
+
+ symbol : Symbol
+ The concerned variable for which the equation is to be checked.
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, exp, Mod
+ >>> from sympy.solvers.solveset import _is_modular as check
+ >>> x, y = symbols('x y')
+ >>> check(Mod(x, 3) - 1, x)
+ True
+ >>> check(Mod(x, 3) - 1, y)
+ False
+ >>> check(Mod(x, 3)**2 - 5, x)
+ False
+ >>> check(Mod(x, 3)**2 - y, x)
+ False
+ >>> check(exp(Mod(x, 3)) - 1, x)
+ False
+ >>> check(Mod(3, y) - 1, y)
+ False
+ """
+
+ if not f.has(Mod):
+ return False
+
+ # extract modterms from f.
+ modterms = list(f.atoms(Mod))
+
+ return (len(modterms) == 1 and # only one Mod should be present
+ modterms[0].args[0].has(symbol) and # B-> function of symbol
+ modterms[0].args[1].is_integer and # C-> to be an integer.
+ any(isinstance(term, Mod)
+ for term in list(_term_factors(f))) # free from other funcs
+ )
+
+
+def _invert_modular(modterm, rhs, n, symbol):
+ """
+ Helper function to invert modular equation.
+ ``Mod(a, m) - rhs = 0``
+
+ Generally it is inverted as (a, ImageSet(Lambda(n, m*n + rhs), S.Integers)).
+ More simplified form will be returned if possible.
+
+ If it is not invertible then (modterm, rhs) is returned.
+
+ The following cases arise while inverting equation ``Mod(a, m) - rhs = 0``:
+
+ 1. If a is symbol then m*n + rhs is the required solution.
+
+ 2. If a is an instance of ``Add`` then we try to find two symbol independent
+ parts of a and the symbol independent part gets transferred to the other
+ side and again the ``_invert_modular`` is called on the symbol
+ dependent part.
+
+ 3. If a is an instance of ``Mul`` then same as we done in ``Add`` we separate
+ out the symbol dependent and symbol independent parts and transfer the
+ symbol independent part to the rhs with the help of invert and again the
+ ``_invert_modular`` is called on the symbol dependent part.
+
+ 4. If a is an instance of ``Pow`` then two cases arise as following:
+
+ - If a is of type (symbol_indep)**(symbol_dep) then the remainder is
+ evaluated with the help of discrete_log function and then the least
+ period is being found out with the help of totient function.
+ period*n + remainder is the required solution in this case.
+ For reference: (https://en.wikipedia.org/wiki/Euler's_theorem)
+
+ - If a is of type (symbol_dep)**(symbol_indep) then we try to find all
+ primitive solutions list with the help of nthroot_mod function.
+ m*n + rem is the general solution where rem belongs to solutions list
+ from nthroot_mod function.
+
+ Parameters
+ ==========
+
+ modterm, rhs : Expr
+ The modular equation to be inverted, ``modterm - rhs = 0``
+
+ symbol : Symbol
+ The variable in the equation to be inverted.
+
+ n : Dummy
+ Dummy variable for output g_n.
+
+ Returns
+ =======
+
+ A tuple (f_x, g_n) is being returned where f_x is modular independent function
+ of symbol and g_n being set of values f_x can have.
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, exp, Mod, Dummy, S
+ >>> from sympy.solvers.solveset import _invert_modular as invert_modular
+ >>> x, y = symbols('x y')
+ >>> n = Dummy('n')
+ >>> invert_modular(Mod(exp(x), 7), S(5), n, x)
+ (Mod(exp(x), 7), 5)
+ >>> invert_modular(Mod(x, 7), S(5), n, x)
+ (x, ImageSet(Lambda(_n, 7*_n + 5), Integers))
+ >>> invert_modular(Mod(3*x + 8, 7), S(5), n, x)
+ (x, ImageSet(Lambda(_n, 7*_n + 6), Integers))
+ >>> invert_modular(Mod(x**4, 7), S(5), n, x)
+ (x, EmptySet)
+ >>> invert_modular(Mod(2**(x**2 + x + 1), 7), S(2), n, x)
+ (x**2 + x + 1, ImageSet(Lambda(_n, 3*_n + 1), Naturals0))
+
+ """
+ a, m = modterm.args
+
+ if rhs.is_real is False or any(term.is_real is False
+ for term in list(_term_factors(a))):
+ # Check for complex arguments
+ return modterm, rhs
+
+ if abs(rhs) >= abs(m):
+ # if rhs has value greater than value of m.
+ return symbol, S.EmptySet
+
+ if a == symbol:
+ return symbol, ImageSet(Lambda(n, m*n + rhs), S.Integers)
+
+ if a.is_Add:
+ # g + h = a
+ g, h = a.as_independent(symbol)
+ if g is not S.Zero:
+ x_indep_term = rhs - Mod(g, m)
+ return _invert_modular(Mod(h, m), Mod(x_indep_term, m), n, symbol)
+
+ if a.is_Mul:
+ # g*h = a
+ g, h = a.as_independent(symbol)
+ if g is not S.One:
+ x_indep_term = rhs*invert(g, m)
+ return _invert_modular(Mod(h, m), Mod(x_indep_term, m), n, symbol)
+
+ if a.is_Pow:
+ # base**expo = a
+ base, expo = a.args
+ if expo.has(symbol) and not base.has(symbol):
+ # remainder -> solution independent of n of equation.
+ # m, rhs are made coprime by dividing igcd(m, rhs)
+ try:
+ remainder = discrete_log(m / igcd(m, rhs), rhs, a.base)
+ except ValueError: # log does not exist
+ return modterm, rhs
+ # period -> coefficient of n in the solution and also referred as
+ # the least period of expo in which it is repeats itself.
+ # (a**(totient(m)) - 1) divides m. Here is link of theorem:
+ # (https://en.wikipedia.org/wiki/Euler's_theorem)
+ period = totient(m)
+ for p in divisors(period):
+ # there might a lesser period exist than totient(m).
+ if pow(a.base, p, m / igcd(m, a.base)) == 1:
+ period = p
+ break
+ # recursion is not applied here since _invert_modular is currently
+ # not smart enough to handle infinite rhs as here expo has infinite
+ # rhs = ImageSet(Lambda(n, period*n + remainder), S.Naturals0).
+ return expo, ImageSet(Lambda(n, period*n + remainder), S.Naturals0)
+ elif base.has(symbol) and not expo.has(symbol):
+ try:
+ remainder_list = nthroot_mod(rhs, expo, m, all_roots=True)
+ if remainder_list == []:
+ return symbol, S.EmptySet
+ except (ValueError, NotImplementedError):
+ return modterm, rhs
+ g_n = S.EmptySet
+ for rem in remainder_list:
+ g_n += ImageSet(Lambda(n, m*n + rem), S.Integers)
+ return base, g_n
+
+ return modterm, rhs
+
+
+def _solve_modular(f, symbol, domain):
+ r"""
+ Helper function for solving modular equations of type ``A - Mod(B, C) = 0``,
+ where A can or cannot be a function of symbol, B is surely a function of
+ symbol and C is an integer.
+
+ Currently ``_solve_modular`` is only able to solve cases
+ where A is not a function of symbol.
+
+ Parameters
+ ==========
+
+ f : Expr
+ The modular equation to be solved, ``f = 0``
+
+ symbol : Symbol
+ The variable in the equation to be solved.
+
+ domain : Set
+ A set over which the equation is solved. It has to be a subset of
+ Integers.
+
+ Returns
+ =======
+
+ A set of integer solutions satisfying the given modular equation.
+ A ``ConditionSet`` if the equation is unsolvable.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.solveset import _solve_modular as solve_modulo
+ >>> from sympy import S, Symbol, sin, Intersection, Interval, Mod
+ >>> x = Symbol('x')
+ >>> solve_modulo(Mod(5*x - 8, 7) - 3, x, S.Integers)
+ ImageSet(Lambda(_n, 7*_n + 5), Integers)
+ >>> solve_modulo(Mod(5*x - 8, 7) - 3, x, S.Reals) # domain should be subset of integers.
+ ConditionSet(x, Eq(Mod(5*x + 6, 7) - 3, 0), Reals)
+ >>> solve_modulo(-7 + Mod(x, 5), x, S.Integers)
+ EmptySet
+ >>> solve_modulo(Mod(12**x, 21) - 18, x, S.Integers)
+ ImageSet(Lambda(_n, 6*_n + 2), Naturals0)
+ >>> solve_modulo(Mod(sin(x), 7) - 3, x, S.Integers) # not solvable
+ ConditionSet(x, Eq(Mod(sin(x), 7) - 3, 0), Integers)
+ >>> solve_modulo(3 - Mod(x, 5), x, Intersection(S.Integers, Interval(0, 100)))
+ Intersection(ImageSet(Lambda(_n, 5*_n + 3), Integers), Range(0, 101, 1))
+ """
+ # extract modterm and g_y from f
+ unsolved_result = ConditionSet(symbol, Eq(f, 0), domain)
+ modterm = list(f.atoms(Mod))[0]
+ rhs = -S.One*(f.subs(modterm, S.Zero))
+ if f.as_coefficients_dict()[modterm].is_negative:
+ # checks if coefficient of modterm is negative in main equation.
+ rhs *= -S.One
+
+ if not domain.is_subset(S.Integers):
+ return unsolved_result
+
+ if rhs.has(symbol):
+ # TODO Case: A-> function of symbol, can be extended here
+ # in future.
+ return unsolved_result
+
+ n = Dummy('n', integer=True)
+ f_x, g_n = _invert_modular(modterm, rhs, n, symbol)
+
+ if f_x == modterm and g_n == rhs:
+ return unsolved_result
+
+ if f_x == symbol:
+ if domain is not S.Integers:
+ return domain.intersect(g_n)
+ return g_n
+
+ if isinstance(g_n, ImageSet):
+ lamda_expr = g_n.lamda.expr
+ lamda_vars = g_n.lamda.variables
+ base_sets = g_n.base_sets
+ sol_set = _solveset(f_x - lamda_expr, symbol, S.Integers)
+ if isinstance(sol_set, FiniteSet):
+ tmp_sol = S.EmptySet
+ for sol in sol_set:
+ tmp_sol += ImageSet(Lambda(lamda_vars, sol), *base_sets)
+ sol_set = tmp_sol
+ else:
+ sol_set = ImageSet(Lambda(lamda_vars, sol_set), *base_sets)
+ return domain.intersect(sol_set)
+
+ return unsolved_result
+
+
+def _term_factors(f):
+ """
+ Iterator to get the factors of all terms present
+ in the given equation.
+
+ Parameters
+ ==========
+ f : Expr
+ Equation that needs to be addressed
+
+ Returns
+ =======
+ Factors of all terms present in the equation.
+
+ Examples
+ ========
+
+ >>> from sympy import symbols
+ >>> from sympy.solvers.solveset import _term_factors
+ >>> x = symbols('x')
+ >>> list(_term_factors(-2 - x**2 + x*(x + 1)))
+ [-2, -1, x**2, x, x + 1]
+ """
+ for add_arg in Add.make_args(f):
+ yield from Mul.make_args(add_arg)
+
+
+def _solve_exponential(lhs, rhs, symbol, domain):
+ r"""
+ Helper function for solving (supported) exponential equations.
+
+ Exponential equations are the sum of (currently) at most
+ two terms with one or both of them having a power with a
+ symbol-dependent exponent.
+
+ For example
+
+ .. math:: 5^{2x + 3} - 5^{3x - 1}
+
+ .. math:: 4^{5 - 9x} - e^{2 - x}
+
+ Parameters
+ ==========
+
+ lhs, rhs : Expr
+ The exponential equation to be solved, `lhs = rhs`
+
+ symbol : Symbol
+ The variable in which the equation is solved
+
+ domain : Set
+ A set over which the equation is solved.
+
+ Returns
+ =======
+
+ A set of solutions satisfying the given equation.
+ A ``ConditionSet`` if the equation is unsolvable or
+ if the assumptions are not properly defined, in that case
+ a different style of ``ConditionSet`` is returned having the
+ solution(s) of the equation with the desired assumptions.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.solveset import _solve_exponential as solve_expo
+ >>> from sympy import symbols, S
+ >>> x = symbols('x', real=True)
+ >>> a, b = symbols('a b')
+ >>> solve_expo(2**x + 3**x - 5**x, 0, x, S.Reals) # not solvable
+ ConditionSet(x, Eq(2**x + 3**x - 5**x, 0), Reals)
+ >>> solve_expo(a**x - b**x, 0, x, S.Reals) # solvable but incorrect assumptions
+ ConditionSet(x, (a > 0) & (b > 0), {0})
+ >>> solve_expo(3**(2*x) - 2**(x + 3), 0, x, S.Reals)
+ {-3*log(2)/(-2*log(3) + log(2))}
+ >>> solve_expo(2**x - 4**x, 0, x, S.Reals)
+ {0}
+
+ * Proof of correctness of the method
+
+ The logarithm function is the inverse of the exponential function.
+ The defining relation between exponentiation and logarithm is:
+
+ .. math:: {\log_b x} = y \enspace if \enspace b^y = x
+
+ Therefore if we are given an equation with exponent terms, we can
+ convert every term to its corresponding logarithmic form. This is
+ achieved by taking logarithms and expanding the equation using
+ logarithmic identities so that it can easily be handled by ``solveset``.
+
+ For example:
+
+ .. math:: 3^{2x} = 2^{x + 3}
+
+ Taking log both sides will reduce the equation to
+
+ .. math:: (2x)\log(3) = (x + 3)\log(2)
+
+ This form can be easily handed by ``solveset``.
+ """
+ unsolved_result = ConditionSet(symbol, Eq(lhs - rhs, 0), domain)
+ newlhs = powdenest(lhs)
+ if lhs != newlhs:
+ # it may also be advantageous to factor the new expr
+ neweq = factor(newlhs - rhs)
+ if neweq != (lhs - rhs):
+ return _solveset(neweq, symbol, domain) # try again with _solveset
+
+ if not (isinstance(lhs, Add) and len(lhs.args) == 2):
+ # solving for the sum of more than two powers is possible
+ # but not yet implemented
+ return unsolved_result
+
+ if rhs != 0:
+ return unsolved_result
+
+ a, b = list(ordered(lhs.args))
+ a_term = a.as_independent(symbol)[1]
+ b_term = b.as_independent(symbol)[1]
+
+ a_base, a_exp = a_term.as_base_exp()
+ b_base, b_exp = b_term.as_base_exp()
+
+ if domain.is_subset(S.Reals):
+ conditions = And(
+ a_base > 0,
+ b_base > 0,
+ Eq(im(a_exp), 0),
+ Eq(im(b_exp), 0))
+ else:
+ conditions = And(
+ Ne(a_base, 0),
+ Ne(b_base, 0))
+
+ L, R = (expand_log(log(i), force=True) for i in (a, -b))
+ solutions = _solveset(L - R, symbol, domain)
+
+ return ConditionSet(symbol, conditions, solutions)
+
+
+def _is_exponential(f, symbol):
+ r"""
+ Return ``True`` if one or more terms contain ``symbol`` only in
+ exponents, else ``False``.
+
+ Parameters
+ ==========
+
+ f : Expr
+ The equation to be checked
+
+ symbol : Symbol
+ The variable in which the equation is checked
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, cos, exp
+ >>> from sympy.solvers.solveset import _is_exponential as check
+ >>> x, y = symbols('x y')
+ >>> check(y, y)
+ False
+ >>> check(x**y - 1, y)
+ True
+ >>> check(x**y*2**y - 1, y)
+ True
+ >>> check(exp(x + 3) + 3**x, x)
+ True
+ >>> check(cos(2**x), x)
+ False
+
+ * Philosophy behind the helper
+
+ The function extracts each term of the equation and checks if it is
+ of exponential form w.r.t ``symbol``.
+ """
+ rv = False
+ for expr_arg in _term_factors(f):
+ if symbol not in expr_arg.free_symbols:
+ continue
+ if (isinstance(expr_arg, Pow) and
+ symbol not in expr_arg.base.free_symbols or
+ isinstance(expr_arg, exp)):
+ rv = True # symbol in exponent
+ else:
+ return False # dependent on symbol in non-exponential way
+ return rv
+
+
+def _solve_logarithm(lhs, rhs, symbol, domain):
+ r"""
+ Helper to solve logarithmic equations which are reducible
+ to a single instance of `\log`.
+
+ Logarithmic equations are (currently) the equations that contains
+ `\log` terms which can be reduced to a single `\log` term or
+ a constant using various logarithmic identities.
+
+ For example:
+
+ .. math:: \log(x) + \log(x - 4)
+
+ can be reduced to:
+
+ .. math:: \log(x(x - 4))
+
+ Parameters
+ ==========
+
+ lhs, rhs : Expr
+ The logarithmic equation to be solved, `lhs = rhs`
+
+ symbol : Symbol
+ The variable in which the equation is solved
+
+ domain : Set
+ A set over which the equation is solved.
+
+ Returns
+ =======
+
+ A set of solutions satisfying the given equation.
+ A ``ConditionSet`` if the equation is unsolvable.
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, log, S
+ >>> from sympy.solvers.solveset import _solve_logarithm as solve_log
+ >>> x = symbols('x')
+ >>> f = log(x - 3) + log(x + 3)
+ >>> solve_log(f, 0, x, S.Reals)
+ {-sqrt(10), sqrt(10)}
+
+ * Proof of correctness
+
+ A logarithm is another way to write exponent and is defined by
+
+ .. math:: {\log_b x} = y \enspace if \enspace b^y = x
+
+ When one side of the equation contains a single logarithm, the
+ equation can be solved by rewriting the equation as an equivalent
+ exponential equation as defined above. But if one side contains
+ more than one logarithm, we need to use the properties of logarithm
+ to condense it into a single logarithm.
+
+ Take for example
+
+ .. math:: \log(2x) - 15 = 0
+
+ contains single logarithm, therefore we can directly rewrite it to
+ exponential form as
+
+ .. math:: x = \frac{e^{15}}{2}
+
+ But if the equation has more than one logarithm as
+
+ .. math:: \log(x - 3) + \log(x + 3) = 0
+
+ we use logarithmic identities to convert it into a reduced form
+
+ Using,
+
+ .. math:: \log(a) + \log(b) = \log(ab)
+
+ the equation becomes,
+
+ .. math:: \log((x - 3)(x + 3))
+
+ This equation contains one logarithm and can be solved by rewriting
+ to exponents.
+ """
+ new_lhs = logcombine(lhs, force=True)
+ new_f = new_lhs - rhs
+
+ return _solveset(new_f, symbol, domain)
+
+
+def _is_logarithmic(f, symbol):
+ r"""
+ Return ``True`` if the equation is in the form
+ `a\log(f(x)) + b\log(g(x)) + ... + c` else ``False``.
+
+ Parameters
+ ==========
+
+ f : Expr
+ The equation to be checked
+
+ symbol : Symbol
+ The variable in which the equation is checked
+
+ Returns
+ =======
+
+ ``True`` if the equation is logarithmic otherwise ``False``.
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, tan, log
+ >>> from sympy.solvers.solveset import _is_logarithmic as check
+ >>> x, y = symbols('x y')
+ >>> check(log(x + 2) - log(x + 3), x)
+ True
+ >>> check(tan(log(2*x)), x)
+ False
+ >>> check(x*log(x), x)
+ False
+ >>> check(x + log(x), x)
+ False
+ >>> check(y + log(x), x)
+ True
+
+ * Philosophy behind the helper
+
+ The function extracts each term and checks whether it is
+ logarithmic w.r.t ``symbol``.
+ """
+ rv = False
+ for term in Add.make_args(f):
+ saw_log = False
+ for term_arg in Mul.make_args(term):
+ if symbol not in term_arg.free_symbols:
+ continue
+ if isinstance(term_arg, log):
+ if saw_log:
+ return False # more than one log in term
+ saw_log = True
+ else:
+ return False # dependent on symbol in non-log way
+ if saw_log:
+ rv = True
+ return rv
+
+
+def _is_lambert(f, symbol):
+ r"""
+ If this returns ``False`` then the Lambert solver (``_solve_lambert``) will not be called.
+
+ Explanation
+ ===========
+
+ Quick check for cases that the Lambert solver might be able to handle.
+
+ 1. Equations containing more than two operands and `symbol`s involving any of
+ `Pow`, `exp`, `HyperbolicFunction`,`TrigonometricFunction`, `log` terms.
+
+ 2. In `Pow`, `exp` the exponent should have `symbol` whereas for
+ `HyperbolicFunction`,`TrigonometricFunction`, `log` should contain `symbol`.
+
+ 3. For `HyperbolicFunction`,`TrigonometricFunction` the number of trigonometric functions in
+ equation should be less than number of symbols. (since `A*cos(x) + B*sin(x) - c`
+ is not the Lambert type).
+
+ Some forms of lambert equations are:
+ 1. X**X = C
+ 2. X*(B*log(X) + D)**A = C
+ 3. A*log(B*X + A) + d*X = C
+ 4. (B*X + A)*exp(d*X + g) = C
+ 5. g*exp(B*X + h) - B*X = C
+ 6. A*D**(E*X + g) - B*X = C
+ 7. A*cos(X) + B*sin(X) - D*X = C
+ 8. A*cosh(X) + B*sinh(X) - D*X = C
+
+ Where X is any variable,
+ A, B, C, D, E are any constants,
+ g, h are linear functions or log terms.
+
+ Parameters
+ ==========
+
+ f : Expr
+ The equation to be checked
+
+ symbol : Symbol
+ The variable in which the equation is checked
+
+ Returns
+ =======
+
+ If this returns ``False`` then the Lambert solver (``_solve_lambert``) will not be called.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.solveset import _is_lambert
+ >>> from sympy import symbols, cosh, sinh, log
+ >>> x = symbols('x')
+
+ >>> _is_lambert(3*log(x) - x*log(3), x)
+ True
+ >>> _is_lambert(log(log(x - 3)) + log(x-3), x)
+ True
+ >>> _is_lambert(cosh(x) - sinh(x), x)
+ False
+ >>> _is_lambert((x**2 - 2*x + 1).subs(x, (log(x) + 3*x)**2 - 1), x)
+ True
+
+ See Also
+ ========
+
+ _solve_lambert
+
+ """
+ term_factors = list(_term_factors(f.expand()))
+
+ # total number of symbols in equation
+ no_of_symbols = len([arg for arg in term_factors if arg.has(symbol)])
+ # total number of trigonometric terms in equation
+ no_of_trig = len([arg for arg in term_factors \
+ if arg.has(HyperbolicFunction, TrigonometricFunction)])
+
+ if f.is_Add and no_of_symbols >= 2:
+ # `log`, `HyperbolicFunction`, `TrigonometricFunction` should have symbols
+ # and no_of_trig < no_of_symbols
+ lambert_funcs = (log, HyperbolicFunction, TrigonometricFunction)
+ if any(isinstance(arg, lambert_funcs)\
+ for arg in term_factors if arg.has(symbol)):
+ if no_of_trig < no_of_symbols:
+ return True
+ # here, `Pow`, `exp` exponent should have symbols
+ elif any(isinstance(arg, (Pow, exp)) \
+ for arg in term_factors if (arg.as_base_exp()[1]).has(symbol)):
+ return True
+ return False
+
+
+def _transolve(f, symbol, domain):
+ r"""
+ Function to solve transcendental equations. It is a helper to
+ ``solveset`` and should be used internally. ``_transolve``
+ currently supports the following class of equations:
+
+ - Exponential equations
+ - Logarithmic equations
+
+ Parameters
+ ==========
+
+ f : Any transcendental equation that needs to be solved.
+ This needs to be an expression, which is assumed
+ to be equal to ``0``.
+
+ symbol : The variable for which the equation is solved.
+ This needs to be of class ``Symbol``.
+
+ domain : A set over which the equation is solved.
+ This needs to be of class ``Set``.
+
+ Returns
+ =======
+
+ Set
+ A set of values for ``symbol`` for which ``f`` is equal to
+ zero. An ``EmptySet`` is returned if ``f`` does not have solutions
+ in respective domain. A ``ConditionSet`` is returned as unsolved
+ object if algorithms to evaluate complete solution are not
+ yet implemented.
+
+ How to use ``_transolve``
+ =========================
+
+ ``_transolve`` should not be used as an independent function, because
+ it assumes that the equation (``f``) and the ``symbol`` comes from
+ ``solveset`` and might have undergone a few modification(s).
+ To use ``_transolve`` as an independent function the equation (``f``)
+ and the ``symbol`` should be passed as they would have been by
+ ``solveset``.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.solveset import _transolve as transolve
+ >>> from sympy.solvers.solvers import _tsolve as tsolve
+ >>> from sympy import symbols, S, pprint
+ >>> x = symbols('x', real=True) # assumption added
+ >>> transolve(5**(x - 3) - 3**(2*x + 1), x, S.Reals)
+ {-(log(3) + 3*log(5))/(-log(5) + 2*log(3))}
+
+ How ``_transolve`` works
+ ========================
+
+ ``_transolve`` uses two types of helper functions to solve equations
+ of a particular class:
+
+ Identifying helpers: To determine whether a given equation
+ belongs to a certain class of equation or not. Returns either
+ ``True`` or ``False``.
+
+ Solving helpers: Once an equation is identified, a corresponding
+ helper either solves the equation or returns a form of the equation
+ that ``solveset`` might better be able to handle.
+
+ * Philosophy behind the module
+
+ The purpose of ``_transolve`` is to take equations which are not
+ already polynomial in their generator(s) and to either recast them
+ as such through a valid transformation or to solve them outright.
+ A pair of helper functions for each class of supported
+ transcendental functions are employed for this purpose. One
+ identifies the transcendental form of an equation and the other
+ either solves it or recasts it into a tractable form that can be
+ solved by ``solveset``.
+ For example, an equation in the form `ab^{f(x)} - cd^{g(x)} = 0`
+ can be transformed to
+ `\log(a) + f(x)\log(b) - \log(c) - g(x)\log(d) = 0`
+ (under certain assumptions) and this can be solved with ``solveset``
+ if `f(x)` and `g(x)` are in polynomial form.
+
+ How ``_transolve`` is better than ``_tsolve``
+ =============================================
+
+ 1) Better output
+
+ ``_transolve`` provides expressions in a more simplified form.
+
+ Consider a simple exponential equation
+
+ >>> f = 3**(2*x) - 2**(x + 3)
+ >>> pprint(transolve(f, x, S.Reals), use_unicode=False)
+ -3*log(2)
+ {------------------}
+ -2*log(3) + log(2)
+ >>> pprint(tsolve(f, x), use_unicode=False)
+ / 3 \
+ | --------|
+ | log(2/9)|
+ [-log\2 /]
+
+ 2) Extensible
+
+ The API of ``_transolve`` is designed such that it is easily
+ extensible, i.e. the code that solves a given class of
+ equations is encapsulated in a helper and not mixed in with
+ the code of ``_transolve`` itself.
+
+ 3) Modular
+
+ ``_transolve`` is designed to be modular i.e, for every class of
+ equation a separate helper for identification and solving is
+ implemented. This makes it easy to change or modify any of the
+ method implemented directly in the helpers without interfering
+ with the actual structure of the API.
+
+ 4) Faster Computation
+
+ Solving equation via ``_transolve`` is much faster as compared to
+ ``_tsolve``. In ``solve``, attempts are made computing every possibility
+ to get the solutions. This series of attempts makes solving a bit
+ slow. In ``_transolve``, computation begins only after a particular
+ type of equation is identified.
+
+ How to add new class of equations
+ =================================
+
+ Adding a new class of equation solver is a three-step procedure:
+
+ - Identify the type of the equations
+
+ Determine the type of the class of equations to which they belong:
+ it could be of ``Add``, ``Pow``, etc. types. Separate internal functions
+ are used for each type. Write identification and solving helpers
+ and use them from within the routine for the given type of equation
+ (after adding it, if necessary). Something like:
+
+ .. code-block:: python
+
+ def add_type(lhs, rhs, x):
+ ....
+ if _is_exponential(lhs, x):
+ new_eq = _solve_exponential(lhs, rhs, x)
+ ....
+ rhs, lhs = eq.as_independent(x)
+ if lhs.is_Add:
+ result = add_type(lhs, rhs, x)
+
+ - Define the identification helper.
+
+ - Define the solving helper.
+
+ Apart from this, a few other things needs to be taken care while
+ adding an equation solver:
+
+ - Naming conventions:
+ Name of the identification helper should be as
+ ``_is_class`` where class will be the name or abbreviation
+ of the class of equation. The solving helper will be named as
+ ``_solve_class``.
+ For example: for exponential equations it becomes
+ ``_is_exponential`` and ``_solve_expo``.
+ - The identifying helpers should take two input parameters,
+ the equation to be checked and the variable for which a solution
+ is being sought, while solving helpers would require an additional
+ domain parameter.
+ - Be sure to consider corner cases.
+ - Add tests for each helper.
+ - Add a docstring to your helper that describes the method
+ implemented.
+ The documentation of the helpers should identify:
+
+ - the purpose of the helper,
+ - the method used to identify and solve the equation,
+ - a proof of correctness
+ - the return values of the helpers
+ """
+
+ def add_type(lhs, rhs, symbol, domain):
+ """
+ Helper for ``_transolve`` to handle equations of
+ ``Add`` type, i.e. equations taking the form as
+ ``a*f(x) + b*g(x) + .... = c``.
+ For example: 4**x + 8**x = 0
+ """
+ result = ConditionSet(symbol, Eq(lhs - rhs, 0), domain)
+
+ # check if it is exponential type equation
+ if _is_exponential(lhs, symbol):
+ result = _solve_exponential(lhs, rhs, symbol, domain)
+ # check if it is logarithmic type equation
+ elif _is_logarithmic(lhs, symbol):
+ result = _solve_logarithm(lhs, rhs, symbol, domain)
+
+ return result
+
+ result = ConditionSet(symbol, Eq(f, 0), domain)
+
+ # invert_complex handles the call to the desired inverter based
+ # on the domain specified.
+ lhs, rhs_s = invert_complex(f, 0, symbol, domain)
+
+ if isinstance(rhs_s, FiniteSet):
+ assert (len(rhs_s.args)) == 1
+ rhs = rhs_s.args[0]
+
+ if lhs.is_Add:
+ result = add_type(lhs, rhs, symbol, domain)
+ else:
+ result = rhs_s
+
+ return result
+
+
+def solveset(f, symbol=None, domain=S.Complexes):
+ r"""Solves a given inequality or equation with set as output
+
+ Parameters
+ ==========
+
+ f : Expr or a relational.
+ The target equation or inequality
+ symbol : Symbol
+ The variable for which the equation is solved
+ domain : Set
+ The domain over which the equation is solved
+
+ Returns
+ =======
+
+ Set
+ A set of values for `symbol` for which `f` is True or is equal to
+ zero. An :class:`~.EmptySet` is returned if `f` is False or nonzero.
+ A :class:`~.ConditionSet` is returned as unsolved object if algorithms
+ to evaluate complete solution are not yet implemented.
+
+ ``solveset`` claims to be complete in the solution set that it returns.
+
+ Raises
+ ======
+
+ NotImplementedError
+ The algorithms to solve inequalities in complex domain are
+ not yet implemented.
+ ValueError
+ The input is not valid.
+ RuntimeError
+ It is a bug, please report to the github issue tracker.
+
+
+ Notes
+ =====
+
+ Python interprets 0 and 1 as False and True, respectively, but
+ in this function they refer to solutions of an expression. So 0 and 1
+ return the domain and EmptySet, respectively, while True and False
+ return the opposite (as they are assumed to be solutions of relational
+ expressions).
+
+
+ See Also
+ ========
+
+ solveset_real: solver for real domain
+ solveset_complex: solver for complex domain
+
+ Examples
+ ========
+
+ >>> from sympy import exp, sin, Symbol, pprint, S, Eq
+ >>> from sympy.solvers.solveset import solveset, solveset_real
+
+ * The default domain is complex. Not specifying a domain will lead
+ to the solving of the equation in the complex domain (and this
+ is not affected by the assumptions on the symbol):
+
+ >>> x = Symbol('x')
+ >>> pprint(solveset(exp(x) - 1, x), use_unicode=False)
+ {2*n*I*pi | n in Integers}
+
+ >>> x = Symbol('x', real=True)
+ >>> pprint(solveset(exp(x) - 1, x), use_unicode=False)
+ {2*n*I*pi | n in Integers}
+
+ * If you want to use ``solveset`` to solve the equation in the
+ real domain, provide a real domain. (Using ``solveset_real``
+ does this automatically.)
+
+ >>> R = S.Reals
+ >>> x = Symbol('x')
+ >>> solveset(exp(x) - 1, x, R)
+ {0}
+ >>> solveset_real(exp(x) - 1, x)
+ {0}
+
+ The solution is unaffected by assumptions on the symbol:
+
+ >>> p = Symbol('p', positive=True)
+ >>> pprint(solveset(p**2 - 4))
+ {-2, 2}
+
+ When a :class:`~.ConditionSet` is returned, symbols with assumptions that
+ would alter the set are replaced with more generic symbols:
+
+ >>> i = Symbol('i', imaginary=True)
+ >>> solveset(Eq(i**2 + i*sin(i), 1), i, domain=S.Reals)
+ ConditionSet(_R, Eq(_R**2 + _R*sin(_R) - 1, 0), Reals)
+
+ * Inequalities can be solved over the real domain only. Use of a complex
+ domain leads to a NotImplementedError.
+
+ >>> solveset(exp(x) > 1, x, R)
+ Interval.open(0, oo)
+
+ """
+ f = sympify(f)
+ symbol = sympify(symbol)
+
+ if f is S.true:
+ return domain
+
+ if f is S.false:
+ return S.EmptySet
+
+ if not isinstance(f, (Expr, Relational, Number)):
+ raise ValueError("%s is not a valid SymPy expression" % f)
+
+ if not isinstance(symbol, (Expr, Relational)) and symbol is not None:
+ raise ValueError("%s is not a valid SymPy symbol" % (symbol,))
+
+ if not isinstance(domain, Set):
+ raise ValueError("%s is not a valid domain" %(domain))
+
+ free_symbols = f.free_symbols
+
+ if f.has(Piecewise):
+ f = piecewise_fold(f)
+
+ if symbol is None and not free_symbols:
+ b = Eq(f, 0)
+ if b is S.true:
+ return domain
+ elif b is S.false:
+ return S.EmptySet
+ else:
+ raise NotImplementedError(filldedent('''
+ relationship between value and 0 is unknown: %s''' % b))
+
+ if symbol is None:
+ if len(free_symbols) == 1:
+ symbol = free_symbols.pop()
+ elif free_symbols:
+ raise ValueError(filldedent('''
+ The independent variable must be specified for a
+ multivariate equation.'''))
+ elif not isinstance(symbol, Symbol):
+ f, s, swap = recast_to_symbols([f], [symbol])
+ # the xreplace will be needed if a ConditionSet is returned
+ return solveset(f[0], s[0], domain).xreplace(swap)
+
+ # solveset should ignore assumptions on symbols
+ if symbol not in _rc:
+ x = _rc[0] if domain.is_subset(S.Reals) else _rc[1]
+ rv = solveset(f.xreplace({symbol: x}), x, domain)
+ # try to use the original symbol if possible
+ try:
+ _rv = rv.xreplace({x: symbol})
+ except TypeError:
+ _rv = rv
+ if rv.dummy_eq(_rv):
+ rv = _rv
+ return rv
+
+ # Abs has its own handling method which avoids the
+ # rewriting property that the first piece of abs(x)
+ # is for x >= 0 and the 2nd piece for x < 0 -- solutions
+ # can look better if the 2nd condition is x <= 0. Since
+ # the solution is a set, duplication of results is not
+ # an issue, e.g. {y, -y} when y is 0 will be {0}
+ f, mask = _masked(f, Abs)
+ f = f.rewrite(Piecewise) # everything that's not an Abs
+ for d, e in mask:
+ # everything *in* an Abs
+ e = e.func(e.args[0].rewrite(Piecewise))
+ f = f.xreplace({d: e})
+ f = piecewise_fold(f)
+
+ return _solveset(f, symbol, domain, _check=True)
+
+
+def solveset_real(f, symbol):
+ return solveset(f, symbol, S.Reals)
+
+
+def solveset_complex(f, symbol):
+ return solveset(f, symbol, S.Complexes)
+
+
+def _solveset_multi(eqs, syms, domains):
+ '''Basic implementation of a multivariate solveset.
+
+ For internal use (not ready for public consumption)'''
+
+ rep = {}
+ for sym, dom in zip(syms, domains):
+ if dom is S.Reals:
+ rep[sym] = Symbol(sym.name, real=True)
+ eqs = [eq.subs(rep) for eq in eqs]
+ syms = [sym.subs(rep) for sym in syms]
+
+ syms = tuple(syms)
+
+ if len(eqs) == 0:
+ return ProductSet(*domains)
+
+ if len(syms) == 1:
+ sym = syms[0]
+ domain = domains[0]
+ solsets = [solveset(eq, sym, domain) for eq in eqs]
+ solset = Intersection(*solsets)
+ return ImageSet(Lambda((sym,), (sym,)), solset).doit()
+
+ eqs = sorted(eqs, key=lambda eq: len(eq.free_symbols & set(syms)))
+
+ for n, eq in enumerate(eqs):
+ sols = []
+ all_handled = True
+ for sym in syms:
+ if sym not in eq.free_symbols:
+ continue
+ sol = solveset(eq, sym, domains[syms.index(sym)])
+
+ if isinstance(sol, FiniteSet):
+ i = syms.index(sym)
+ symsp = syms[:i] + syms[i+1:]
+ domainsp = domains[:i] + domains[i+1:]
+ eqsp = eqs[:n] + eqs[n+1:]
+ for s in sol:
+ eqsp_sub = [eq.subs(sym, s) for eq in eqsp]
+ sol_others = _solveset_multi(eqsp_sub, symsp, domainsp)
+ fun = Lambda((symsp,), symsp[:i] + (s,) + symsp[i:])
+ sols.append(ImageSet(fun, sol_others).doit())
+ else:
+ all_handled = False
+ if all_handled:
+ return Union(*sols)
+
+
+def solvify(f, symbol, domain):
+ """Solves an equation using solveset and returns the solution in accordance
+ with the `solve` output API.
+
+ Returns
+ =======
+
+ We classify the output based on the type of solution returned by `solveset`.
+
+ Solution | Output
+ ----------------------------------------
+ FiniteSet | list
+
+ ImageSet, | list (if `f` is periodic)
+ Union |
+
+ Union | list (with FiniteSet)
+
+ EmptySet | empty list
+
+ Others | None
+
+
+ Raises
+ ======
+
+ NotImplementedError
+ A ConditionSet is the input.
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.solveset import solvify
+ >>> from sympy.abc import x
+ >>> from sympy import S, tan, sin, exp
+ >>> solvify(x**2 - 9, x, S.Reals)
+ [-3, 3]
+ >>> solvify(sin(x) - 1, x, S.Reals)
+ [pi/2]
+ >>> solvify(tan(x), x, S.Reals)
+ [0]
+ >>> solvify(exp(x) - 1, x, S.Complexes)
+
+ >>> solvify(exp(x) - 1, x, S.Reals)
+ [0]
+
+ """
+ solution_set = solveset(f, symbol, domain)
+ result = None
+ if solution_set is S.EmptySet:
+ result = []
+
+ elif isinstance(solution_set, ConditionSet):
+ raise NotImplementedError('solveset is unable to solve this equation.')
+
+ elif isinstance(solution_set, FiniteSet):
+ result = list(solution_set)
+
+ else:
+ period = periodicity(f, symbol)
+ if period is not None:
+ solutions = S.EmptySet
+ iter_solutions = ()
+ if isinstance(solution_set, ImageSet):
+ iter_solutions = (solution_set,)
+ elif isinstance(solution_set, Union):
+ if all(isinstance(i, ImageSet) for i in solution_set.args):
+ iter_solutions = solution_set.args
+
+ for solution in iter_solutions:
+ solutions += solution.intersect(Interval(0, period, False, True))
+
+ if isinstance(solutions, FiniteSet):
+ result = list(solutions)
+
+ else:
+ solution = solution_set.intersect(domain)
+ if isinstance(solution, Union):
+ # concerned about only FiniteSet with Union but not about ImageSet
+ # if required could be extend
+ if any(isinstance(i, FiniteSet) for i in solution.args):
+ result = [sol for soln in solution.args \
+ for sol in soln.args if isinstance(soln,FiniteSet)]
+ else:
+ return None
+
+ elif isinstance(solution, FiniteSet):
+ result += solution
+
+ return result
+
+
+###############################################################################
+################################ LINSOLVE #####################################
+###############################################################################
+
+
+def linear_coeffs(eq, *syms, dict=False):
+ """Return a list whose elements are the coefficients of the
+ corresponding symbols in the sum of terms in ``eq``.
+ The additive constant is returned as the last element of the
+ list.
+
+ Raises
+ ======
+
+ NonlinearError
+ The equation contains a nonlinear term
+ ValueError
+ duplicate or unordered symbols are passed
+
+ Parameters
+ ==========
+
+ dict - (default False) when True, return coefficients as a
+ dictionary with coefficients keyed to syms that were present;
+ key 1 gives the constant term
+
+ Examples
+ ========
+
+ >>> from sympy.solvers.solveset import linear_coeffs
+ >>> from sympy.abc import x, y, z
+ >>> linear_coeffs(3*x + 2*y - 1, x, y)
+ [3, 2, -1]
+
+ It is not necessary to expand the expression:
+
+ >>> linear_coeffs(x + y*(z*(x*3 + 2) + 3), x)
+ [3*y*z + 1, y*(2*z + 3)]
+
+ When nonlinear is detected, an error will be raised:
+
+ * even if they would cancel after expansion (so the
+ situation does not pass silently past the caller's
+ attention)
+
+ >>> eq = 1/x*(x - 1) + 1/x
+ >>> linear_coeffs(eq.expand(), x)
+ [0, 1]
+ >>> linear_coeffs(eq, x)
+ Traceback (most recent call last):
+ ...
+ NonlinearError:
+ nonlinear in given generators
+
+ * when there are cross terms
+
+ >>> linear_coeffs(x*(y + 1), x, y)
+ Traceback (most recent call last):
+ ...
+ NonlinearError:
+ symbol-dependent cross-terms encountered
+
+ * when there are terms that contain an expression
+ dependent on the symbols that is not linear
+
+ >>> linear_coeffs(x**2, x)
+ Traceback (most recent call last):
+ ...
+ NonlinearError:
+ nonlinear in given generators
+ """
+ eq = _sympify(eq)
+ if len(syms) == 1 and iterable(syms[0]) and not isinstance(syms[0], Basic):
+ raise ValueError('expecting unpacked symbols, *syms')
+ symset = set(syms)
+ if len(symset) != len(syms):
+ raise ValueError('duplicate symbols given')
+ try:
+ d, c = _linear_eq_to_dict([eq], symset)
+ d = d[0]
+ c = c[0]
+ except PolyNonlinearError as err:
+ raise NonlinearError(str(err))
+ if dict:
+ if c:
+ d[S.One] = c
+ return d
+ rv = [S.Zero]*(len(syms) + 1)
+ rv[-1] = c
+ for i, k in enumerate(syms):
+ if k not in d:
+ continue
+ rv[i] = d[k]
+ return rv
+
+
+def linear_eq_to_matrix(equations, *symbols):
+ r"""
+ Converts a given System of Equations into Matrix form.
+ Here `equations` must be a linear system of equations in
+ `symbols`. Element ``M[i, j]`` corresponds to the coefficient
+ of the jth symbol in the ith equation.
+
+ The Matrix form corresponds to the augmented matrix form.
+ For example:
+
+ .. math:: 4x + 2y + 3z = 1
+ .. math:: 3x + y + z = -6
+ .. math:: 2x + 4y + 9z = 2
+
+ This system will return $A$ and $b$ as:
+
+ $$ A = \left[\begin{array}{ccc}
+ 4 & 2 & 3 \\
+ 3 & 1 & 1 \\
+ 2 & 4 & 9
+ \end{array}\right] \ \ b = \left[\begin{array}{c}
+ 1 \\ -6 \\ 2
+ \end{array}\right] $$
+
+ The only simplification performed is to convert
+ ``Eq(a, b)`` $\Rightarrow a - b$.
+
+ Raises
+ ======
+
+ NonlinearError
+ The equations contain a nonlinear term.
+ ValueError
+ The symbols are not given or are not unique.
+
+ Examples
+ ========
+
+ >>> from sympy import linear_eq_to_matrix, symbols
+ >>> c, x, y, z = symbols('c, x, y, z')
+
+ The coefficients (numerical or symbolic) of the symbols will
+ be returned as matrices:
+
+ >>> eqns = [c*x + z - 1 - c, y + z, x - y]
+ >>> A, b = linear_eq_to_matrix(eqns, [x, y, z])
+ >>> A
+ Matrix([
+ [c, 0, 1],
+ [0, 1, 1],
+ [1, -1, 0]])
+ >>> b
+ Matrix([
+ [c + 1],
+ [ 0],
+ [ 0]])
+
+ This routine does not simplify expressions and will raise an error
+ if nonlinearity is encountered:
+
+ >>> eqns = [
+ ... (x**2 - 3*x)/(x - 3) - 3,
+ ... y**2 - 3*y - y*(y - 4) + x - 4]
+ >>> linear_eq_to_matrix(eqns, [x, y])
+ Traceback (most recent call last):
+ ...
+ NonlinearError:
+ symbol-dependent term can be ignored using `strict=False`
+
+ Simplifying these equations will discard the removable singularity
+ in the first and reveal the linear structure of the second:
+
+ >>> [e.simplify() for e in eqns]
+ [x - 3, x + y - 4]
+
+ Any such simplification needed to eliminate nonlinear terms must
+ be done *before* calling this routine.
+ """
+ if not symbols:
+ raise ValueError(filldedent('''
+ Symbols must be given, for which coefficients
+ are to be found.
+ '''))
+
+ if hasattr(symbols[0], '__iter__'):
+ symbols = symbols[0]
+
+ if has_dups(symbols):
+ raise ValueError('Symbols must be unique')
+
+ equations = sympify(equations)
+ if isinstance(equations, MatrixBase):
+ equations = list(equations)
+ elif isinstance(equations, (Expr, Eq)):
+ equations = [equations]
+ elif not is_sequence(equations):
+ raise ValueError(filldedent('''
+ Equation(s) must be given as a sequence, Expr,
+ Eq or Matrix.
+ '''))
+
+ # construct the dictionaries
+ try:
+ eq, c = _linear_eq_to_dict(equations, symbols)
+ except PolyNonlinearError as err:
+ raise NonlinearError(str(err))
+ # prepare output matrices
+ n, m = shape = len(eq), len(symbols)
+ ix = dict(zip(symbols, range(m)))
+ A = zeros(*shape)
+ for row, d in enumerate(eq):
+ for k in d:
+ col = ix[k]
+ A[row, col] = d[k]
+ b = Matrix(n, 1, [-i for i in c])
+ return A, b
+
+
+def linsolve(system, *symbols):
+ r"""
+ Solve system of $N$ linear equations with $M$ variables; both
+ underdetermined and overdetermined systems are supported.
+ The possible number of solutions is zero, one or infinite.
+ Zero solutions throws a ValueError, whereas infinite
+ solutions are represented parametrically in terms of the given
+ symbols. For unique solution a :class:`~.FiniteSet` of ordered tuples
+ is returned.
+
+ All standard input formats are supported:
+ For the given set of equations, the respective input types
+ are given below:
+
+ .. math:: 3x + 2y - z = 1
+ .. math:: 2x - 2y + 4z = -2
+ .. math:: 2x - y + 2z = 0
+
+ * Augmented matrix form, ``system`` given below:
+
+ $$ \text{system} = \left[{array}{cccc}
+ 3 & 2 & -1 & 1\\
+ 2 & -2 & 4 & -2\\
+ 2 & -1 & 2 & 0
+ \end{array}\right] $$
+
+ ::
+
+ system = Matrix([[3, 2, -1, 1], [2, -2, 4, -2], [2, -1, 2, 0]])
+
+ * List of equations form
+
+ ::
+
+ system = [3x + 2y - z - 1, 2x - 2y + 4z + 2, 2x - y + 2z]
+
+ * Input $A$ and $b$ in matrix form (from $Ax = b$) are given as:
+
+ $$ A = \left[\begin{array}{ccc}
+ 3 & 2 & -1 \\
+ 2 & -2 & 4 \\
+ 2 & -1 & 2
+ \end{array}\right] \ \ b = \left[\begin{array}{c}
+ 1 \\ -2 \\ 0
+ \end{array}\right] $$
+
+ ::
+
+ A = Matrix([[3, 2, -1], [2, -2, 4], [2, -1, 2]])
+ b = Matrix([[1], [-2], [0]])
+ system = (A, b)
+
+ Symbols can always be passed but are actually only needed
+ when 1) a system of equations is being passed and 2) the
+ system is passed as an underdetermined matrix and one wants
+ to control the name of the free variables in the result.
+ An error is raised if no symbols are used for case 1, but if
+ no symbols are provided for case 2, internally generated symbols
+ will be provided. When providing symbols for case 2, there should
+ be at least as many symbols are there are columns in matrix A.
+
+ The algorithm used here is Gauss-Jordan elimination, which
+ results, after elimination, in a row echelon form matrix.
+
+ Returns
+ =======
+
+ A FiniteSet containing an ordered tuple of values for the
+ unknowns for which the `system` has a solution. (Wrapping
+ the tuple in FiniteSet is used to maintain a consistent
+ output format throughout solveset.)
+
+ Returns EmptySet, if the linear system is inconsistent.
+
+ Raises
+ ======
+
+ ValueError
+ The input is not valid.
+ The symbols are not given.
+
+ Examples
+ ========
+
+ >>> from sympy import Matrix, linsolve, symbols
+ >>> x, y, z = symbols("x, y, z")
+ >>> A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 10]])
+ >>> b = Matrix([3, 6, 9])
+ >>> A
+ Matrix([
+ [1, 2, 3],
+ [4, 5, 6],
+ [7, 8, 10]])
+ >>> b
+ Matrix([
+ [3],
+ [6],
+ [9]])
+ >>> linsolve((A, b), [x, y, z])
+ {(-1, 2, 0)}
+
+ * Parametric Solution: In case the system is underdetermined, the
+ function will return a parametric solution in terms of the given
+ symbols. Those that are free will be returned unchanged. e.g. in
+ the system below, `z` is returned as the solution for variable z;
+ it can take on any value.
+
+ >>> A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+ >>> b = Matrix([3, 6, 9])
+ >>> linsolve((A, b), x, y, z)
+ {(z - 1, 2 - 2*z, z)}
+
+ If no symbols are given, internally generated symbols will be used.
+ The ``tau0`` in the third position indicates (as before) that the third
+ variable -- whatever it is named -- can take on any value:
+
+ >>> linsolve((A, b))
+ {(tau0 - 1, 2 - 2*tau0, tau0)}
+
+ * List of equations as input
+
+ >>> Eqns = [3*x + 2*y - z - 1, 2*x - 2*y + 4*z + 2, - x + y/2 - z]
+ >>> linsolve(Eqns, x, y, z)
+ {(1, -2, -2)}
+
+ * Augmented matrix as input
+
+ >>> aug = Matrix([[2, 1, 3, 1], [2, 6, 8, 3], [6, 8, 18, 5]])
+ >>> aug
+ Matrix([
+ [2, 1, 3, 1],
+ [2, 6, 8, 3],
+ [6, 8, 18, 5]])
+ >>> linsolve(aug, x, y, z)
+ {(3/10, 2/5, 0)}
+
+ * Solve for symbolic coefficients
+
+ >>> a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+ >>> eqns = [a*x + b*y - c, d*x + e*y - f]
+ >>> linsolve(eqns, x, y)
+ {((-b*f + c*e)/(a*e - b*d), (a*f - c*d)/(a*e - b*d))}
+
+ * A degenerate system returns solution as set of given
+ symbols.
+
+ >>> system = Matrix(([0, 0, 0], [0, 0, 0], [0, 0, 0]))
+ >>> linsolve(system, x, y)
+ {(x, y)}
+
+ * For an empty system linsolve returns empty set
+
+ >>> linsolve([], x)
+ EmptySet
+
+ * An error is raised if any nonlinearity is detected, even
+ if it could be removed with expansion
+
+ >>> linsolve([x*(1/x - 1)], x)
+ Traceback (most recent call last):
+ ...
+ NonlinearError: nonlinear term: 1/x
+
+ >>> linsolve([x*(y + 1)], x, y)
+ Traceback (most recent call last):
+ ...
+ NonlinearError: nonlinear cross-term: x*(y + 1)
+
+ >>> linsolve([x**2 - 1], x)
+ Traceback (most recent call last):
+ ...
+ NonlinearError: nonlinear term: x**2
+ """
+ if not system:
+ return S.EmptySet
+
+ # If second argument is an iterable
+ if symbols and hasattr(symbols[0], '__iter__'):
+ symbols = symbols[0]
+ sym_gen = isinstance(symbols, GeneratorType)
+ dup_msg = 'duplicate symbols given'
+
+
+ b = None # if we don't get b the input was bad
+ # unpack system
+
+ if hasattr(system, '__iter__'):
+
+ # 1). (A, b)
+ if len(system) == 2 and isinstance(system[0], MatrixBase):
+ A, b = system
+
+ # 2). (eq1, eq2, ...)
+ if not isinstance(system[0], MatrixBase):
+ if sym_gen or not symbols:
+ raise ValueError(filldedent('''
+ When passing a system of equations, the explicit
+ symbols for which a solution is being sought must
+ be given as a sequence, too.
+ '''))
+ if len(set(symbols)) != len(symbols):
+ raise ValueError(dup_msg)
+
+ #
+ # Pass to the sparse solver implemented in polys. It is important
+ # that we do not attempt to convert the equations to a matrix
+ # because that would be very inefficient for large sparse systems
+ # of equations.
+ #
+ eqs = system
+ eqs = [sympify(eq) for eq in eqs]
+ try:
+ sol = _linsolve(eqs, symbols)
+ except PolyNonlinearError as exc:
+ # e.g. cos(x) contains an element of the set of generators
+ raise NonlinearError(str(exc))
+
+ if sol is None:
+ return S.EmptySet
+
+ sol = FiniteSet(Tuple(*(sol.get(sym, sym) for sym in symbols)))
+ return sol
+
+ elif isinstance(system, MatrixBase) and not (
+ symbols and not isinstance(symbols, GeneratorType) and
+ isinstance(symbols[0], MatrixBase)):
+ # 3). A augmented with b
+ A, b = system[:, :-1], system[:, -1:]
+
+ if b is None:
+ raise ValueError("Invalid arguments")
+ if sym_gen:
+ symbols = [next(symbols) for i in range(A.cols)]
+ symset = set(symbols)
+ if any(symset & (A.free_symbols | b.free_symbols)):
+ raise ValueError(filldedent('''
+ At least one of the symbols provided
+ already appears in the system to be solved.
+ One way to avoid this is to use Dummy symbols in
+ the generator, e.g. numbered_symbols('%s', cls=Dummy)
+ ''' % symbols[0].name.rstrip('1234567890')))
+ elif len(symset) != len(symbols):
+ raise ValueError(dup_msg)
+
+ if not symbols:
+ symbols = [Dummy() for _ in range(A.cols)]
+ name = _uniquely_named_symbol('tau', (A, b),
+ compare=lambda i: str(i).rstrip('1234567890')).name
+ gen = numbered_symbols(name)
+ else:
+ gen = None
+
+ # This is just a wrapper for solve_lin_sys
+ eqs = []
+ rows = A.tolist()
+ for rowi, bi in zip(rows, b):
+ terms = [elem * sym for elem, sym in zip(rowi, symbols) if elem]
+ terms.append(-bi)
+ eqs.append(Add(*terms))
+
+ eqs, ring = sympy_eqs_to_ring(eqs, symbols)
+ sol = solve_lin_sys(eqs, ring, _raw=False)
+ if sol is None:
+ return S.EmptySet
+ #sol = {sym:val for sym, val in sol.items() if sym != val}
+ sol = FiniteSet(Tuple(*(sol.get(sym, sym) for sym in symbols)))
+
+ if gen is not None:
+ solsym = sol.free_symbols
+ rep = {sym: next(gen) for sym in symbols if sym in solsym}
+ sol = sol.subs(rep)
+
+ return sol
+
+
+##############################################################################
+# ------------------------------nonlinsolve ---------------------------------#
+##############################################################################
+
+
+def _return_conditionset(eqs, symbols):
+ # return conditionset
+ eqs = (Eq(lhs, 0) for lhs in eqs)
+ condition_set = ConditionSet(
+ Tuple(*symbols), And(*eqs), S.Complexes**len(symbols))
+ return condition_set
+
+
+def substitution(system, symbols, result=[{}], known_symbols=[],
+ exclude=[], all_symbols=None):
+ r"""
+ Solves the `system` using substitution method. It is used in
+ :func:`~.nonlinsolve`. This will be called from :func:`~.nonlinsolve` when any
+ equation(s) is non polynomial equation.
+
+ Parameters
+ ==========
+
+ system : list of equations
+ The target system of equations
+ symbols : list of symbols to be solved.
+ The variable(s) for which the system is solved
+ known_symbols : list of solved symbols
+ Values are known for these variable(s)
+ result : An empty list or list of dict
+ If No symbol values is known then empty list otherwise
+ symbol as keys and corresponding value in dict.
+ exclude : Set of expression.
+ Mostly denominator expression(s) of the equations of the system.
+ Final solution should not satisfy these expressions.
+ all_symbols : known_symbols + symbols(unsolved).
+
+ Returns
+ =======
+
+ A FiniteSet of ordered tuple of values of `all_symbols` for which the
+ `system` has solution. Order of values in the tuple is same as symbols
+ present in the parameter `all_symbols`. If parameter `all_symbols` is None
+ then same as symbols present in the parameter `symbols`.
+
+ Please note that general FiniteSet is unordered, the solution returned
+ here is not simply a FiniteSet of solutions, rather it is a FiniteSet of
+ ordered tuple, i.e. the first & only argument to FiniteSet is a tuple of
+ solutions, which is ordered, & hence the returned solution is ordered.
+
+ Also note that solution could also have been returned as an ordered tuple,
+ FiniteSet is just a wrapper `{}` around the tuple. It has no other
+ significance except for the fact it is just used to maintain a consistent
+ output format throughout the solveset.
+
+ Raises
+ ======
+
+ ValueError
+ The input is not valid.
+ The symbols are not given.
+ AttributeError
+ The input symbols are not :class:`~.Symbol` type.
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, substitution
+ >>> x, y = symbols('x, y', real=True)
+ >>> substitution([x + y], [x], [{y: 1}], [y], set([]), [x, y])
+ {(-1, 1)}
+
+ * When you want a soln not satisfying $x + 1 = 0$
+
+ >>> substitution([x + y], [x], [{y: 1}], [y], set([x + 1]), [y, x])
+ EmptySet
+ >>> substitution([x + y], [x], [{y: 1}], [y], set([x - 1]), [y, x])
+ {(1, -1)}
+ >>> substitution([x + y - 1, y - x**2 + 5], [x, y])
+ {(-3, 4), (2, -1)}
+
+ * Returns both real and complex solution
+
+ >>> x, y, z = symbols('x, y, z')
+ >>> from sympy import exp, sin
+ >>> substitution([exp(x) - sin(y), y**2 - 4], [x, y])
+ {(ImageSet(Lambda(_n, I*(2*_n*pi + pi) + log(sin(2))), Integers), -2),
+ (ImageSet(Lambda(_n, 2*_n*I*pi + log(sin(2))), Integers), 2)}
+
+ >>> eqs = [z**2 + exp(2*x) - sin(y), -3 + exp(-y)]
+ >>> substitution(eqs, [y, z])
+ {(-log(3), -sqrt(-exp(2*x) - sin(log(3)))),
+ (-log(3), sqrt(-exp(2*x) - sin(log(3)))),
+ (ImageSet(Lambda(_n, 2*_n*I*pi - log(3)), Integers),
+ ImageSet(Lambda(_n, -sqrt(-exp(2*x) + sin(2*_n*I*pi - log(3)))), Integers)),
+ (ImageSet(Lambda(_n, 2*_n*I*pi - log(3)), Integers),
+ ImageSet(Lambda(_n, sqrt(-exp(2*x) + sin(2*_n*I*pi - log(3)))), Integers))}
+
+ """
+
+ if not system:
+ return S.EmptySet
+
+ if not symbols:
+ msg = ('Symbols must be given, for which solution of the '
+ 'system is to be found.')
+ raise ValueError(filldedent(msg))
+
+ if not is_sequence(symbols):
+ msg = ('symbols should be given as a sequence, e.g. a list.'
+ 'Not type %s: %s')
+ raise TypeError(filldedent(msg % (type(symbols), symbols)))
+
+ if not getattr(symbols[0], 'is_Symbol', False):
+ msg = ('Iterable of symbols must be given as '
+ 'second argument, not type %s: %s')
+ raise ValueError(filldedent(msg % (type(symbols[0]), symbols[0])))
+
+ # By default `all_symbols` will be same as `symbols`
+ if all_symbols is None:
+ all_symbols = symbols
+
+ old_result = result
+ # storing complements and intersection for particular symbol
+ complements = {}
+ intersections = {}
+
+ # when total_solveset_call equals total_conditionset
+ # it means that solveset failed to solve all eqs.
+ total_conditionset = -1
+ total_solveset_call = -1
+
+ def _unsolved_syms(eq, sort=False):
+ """Returns the unsolved symbol present
+ in the equation `eq`.
+ """
+ free = eq.free_symbols
+ unsolved = (free - set(known_symbols)) & set(all_symbols)
+ if sort:
+ unsolved = list(unsolved)
+ unsolved.sort(key=default_sort_key)
+ return unsolved
+ # end of _unsolved_syms()
+
+ # sort such that equation with the fewest potential symbols is first.
+ # means eq with less number of variable first in the list.
+ eqs_in_better_order = list(
+ ordered(system, lambda _: len(_unsolved_syms(_))))
+
+ def add_intersection_complement(result, intersection_dict, complement_dict):
+ # If solveset has returned some intersection/complement
+ # for any symbol, it will be added in the final solution.
+ final_result = []
+ for res in result:
+ res_copy = res
+ for key_res, value_res in res.items():
+ intersect_set, complement_set = None, None
+ for key_sym, value_sym in intersection_dict.items():
+ if key_sym == key_res:
+ intersect_set = value_sym
+ for key_sym, value_sym in complement_dict.items():
+ if key_sym == key_res:
+ complement_set = value_sym
+ if intersect_set or complement_set:
+ new_value = FiniteSet(value_res)
+ if intersect_set and intersect_set != S.Complexes:
+ new_value = Intersection(new_value, intersect_set)
+ if complement_set:
+ new_value = Complement(new_value, complement_set)
+ if new_value is S.EmptySet:
+ res_copy = None
+ break
+ elif new_value.is_FiniteSet and len(new_value) == 1:
+ res_copy[key_res] = set(new_value).pop()
+ else:
+ res_copy[key_res] = new_value
+
+ if res_copy is not None:
+ final_result.append(res_copy)
+ return final_result
+ # end of def add_intersection_complement()
+
+ def _extract_main_soln(sym, sol, soln_imageset):
+ """Separate the Complements, Intersections, ImageSet lambda expr and
+ its base_set. This function returns the unmasks sol from different classes
+ of sets and also returns the appended ImageSet elements in a
+ soln_imageset (dict: where key as unmasked element and value as ImageSet).
+ """
+ # if there is union, then need to check
+ # Complement, Intersection, Imageset.
+ # Order should not be changed.
+ if isinstance(sol, ConditionSet):
+ # extracts any solution in ConditionSet
+ sol = sol.base_set
+
+ if isinstance(sol, Complement):
+ # extract solution and complement
+ complements[sym] = sol.args[1]
+ sol = sol.args[0]
+ # complement will be added at the end
+ # using `add_intersection_complement` method
+
+ # if there is union of Imageset or other in soln.
+ # no testcase is written for this if block
+ if isinstance(sol, Union):
+ sol_args = sol.args
+ sol = S.EmptySet
+ # We need in sequence so append finteset elements
+ # and then imageset or other.
+ for sol_arg2 in sol_args:
+ if isinstance(sol_arg2, FiniteSet):
+ sol += sol_arg2
+ else:
+ # ImageSet, Intersection, complement then
+ # append them directly
+ sol += FiniteSet(sol_arg2)
+
+ if isinstance(sol, Intersection):
+ # Interval/Set will be at 0th index always
+ if sol.args[0] not in (S.Reals, S.Complexes):
+ # Sometimes solveset returns soln with intersection
+ # S.Reals or S.Complexes. We don't consider that
+ # intersection.
+ intersections[sym] = sol.args[0]
+ sol = sol.args[1]
+ # after intersection and complement Imageset should
+ # be checked.
+ if isinstance(sol, ImageSet):
+ soln_imagest = sol
+ expr2 = sol.lamda.expr
+ sol = FiniteSet(expr2)
+ soln_imageset[expr2] = soln_imagest
+
+ if not isinstance(sol, FiniteSet):
+ sol = FiniteSet(sol)
+ return sol, soln_imageset
+ # end of def _extract_main_soln()
+
+ # helper function for _append_new_soln
+ def _check_exclude(rnew, imgset_yes):
+ rnew_ = rnew
+ if imgset_yes:
+ # replace all dummy variables (Imageset lambda variables)
+ # with zero before `checksol`. Considering fundamental soln
+ # for `checksol`.
+ rnew_copy = rnew.copy()
+ dummy_n = imgset_yes[0]
+ for key_res, value_res in rnew_copy.items():
+ rnew_copy[key_res] = value_res.subs(dummy_n, 0)
+ rnew_ = rnew_copy
+ # satisfy_exclude == true if it satisfies the expr of `exclude` list.
+ try:
+ # something like : `Mod(-log(3), 2*I*pi)` can't be
+ # simplified right now, so `checksol` returns `TypeError`.
+ # when this issue is fixed this try block should be
+ # removed. Mod(-log(3), 2*I*pi) == -log(3)
+ satisfy_exclude = any(
+ checksol(d, rnew_) for d in exclude)
+ except TypeError:
+ satisfy_exclude = None
+ return satisfy_exclude
+ # end of def _check_exclude()
+
+ # helper function for _append_new_soln
+ def _restore_imgset(rnew, original_imageset, newresult):
+ restore_sym = set(rnew.keys()) & \
+ set(original_imageset.keys())
+ for key_sym in restore_sym:
+ img = original_imageset[key_sym]
+ rnew[key_sym] = img
+ if rnew not in newresult:
+ newresult.append(rnew)
+ # end of def _restore_imgset()
+
+ def _append_eq(eq, result, res, delete_soln, n=None):
+ u = Dummy('u')
+ if n:
+ eq = eq.subs(n, 0)
+ satisfy = eq if eq in (True, False) else checksol(u, u, eq, minimal=True)
+ if satisfy is False:
+ delete_soln = True
+ res = {}
+ else:
+ result.append(res)
+ return result, res, delete_soln
+
+ def _append_new_soln(rnew, sym, sol, imgset_yes, soln_imageset,
+ original_imageset, newresult, eq=None):
+ """If `rnew` (A dict ) contains valid soln
+ append it to `newresult` list.
+ `imgset_yes` is (base, dummy_var) if there was imageset in previously
+ calculated result(otherwise empty tuple). `original_imageset` is dict
+ of imageset expr and imageset from this result.
+ `soln_imageset` dict of imageset expr and imageset of new soln.
+ """
+ satisfy_exclude = _check_exclude(rnew, imgset_yes)
+ delete_soln = False
+ # soln should not satisfy expr present in `exclude` list.
+ if not satisfy_exclude:
+ local_n = None
+ # if it is imageset
+ if imgset_yes:
+ local_n = imgset_yes[0]
+ base = imgset_yes[1]
+ if sym and sol:
+ # when `sym` and `sol` is `None` means no new
+ # soln. In that case we will append rnew directly after
+ # substituting original imagesets in rnew values if present
+ # (second last line of this function using _restore_imgset)
+ dummy_list = list(sol.atoms(Dummy))
+ # use one dummy `n` which is in
+ # previous imageset
+ local_n_list = [
+ local_n for i in range(
+ 0, len(dummy_list))]
+
+ dummy_zip = zip(dummy_list, local_n_list)
+ lam = Lambda(local_n, sol.subs(dummy_zip))
+ rnew[sym] = ImageSet(lam, base)
+ if eq is not None:
+ newresult, rnew, delete_soln = _append_eq(
+ eq, newresult, rnew, delete_soln, local_n)
+ elif eq is not None:
+ newresult, rnew, delete_soln = _append_eq(
+ eq, newresult, rnew, delete_soln)
+ elif sol in soln_imageset.keys():
+ rnew[sym] = soln_imageset[sol]
+ # restore original imageset
+ _restore_imgset(rnew, original_imageset, newresult)
+ else:
+ newresult.append(rnew)
+ elif satisfy_exclude:
+ delete_soln = True
+ rnew = {}
+ _restore_imgset(rnew, original_imageset, newresult)
+ return newresult, delete_soln
+ # end of def _append_new_soln()
+
+ def _new_order_result(result, eq):
+ # separate first, second priority. `res` that makes `eq` value equals
+ # to zero, should be used first then other result(second priority).
+ # If it is not done then we may miss some soln.
+ first_priority = []
+ second_priority = []
+ for res in result:
+ if not any(isinstance(val, ImageSet) for val in res.values()):
+ if eq.subs(res) == 0:
+ first_priority.append(res)
+ else:
+ second_priority.append(res)
+ if first_priority or second_priority:
+ return first_priority + second_priority
+ return result
+
+ def _solve_using_known_values(result, solver):
+ """Solves the system using already known solution
+ (result contains the dict ).
+ solver is :func:`~.solveset_complex` or :func:`~.solveset_real`.
+ """
+ # stores imageset .
+ soln_imageset = {}
+ total_solvest_call = 0
+ total_conditionst = 0
+
+ # sort such that equation with the fewest potential symbols is first.
+ # means eq with less variable first
+ for index, eq in enumerate(eqs_in_better_order):
+ newresult = []
+ original_imageset = {}
+ # if imageset expr is used to solve other symbol
+ imgset_yes = False
+ result = _new_order_result(result, eq)
+ for res in result:
+ got_symbol = set() # symbols solved in one iteration
+ # find the imageset and use its expr.
+ for key_res, value_res in res.items():
+ if isinstance(value_res, ImageSet):
+ res[key_res] = value_res.lamda.expr
+ original_imageset[key_res] = value_res
+ dummy_n = value_res.lamda.expr.atoms(Dummy).pop()
+ (base,) = value_res.base_sets
+ imgset_yes = (dummy_n, base)
+ # update eq with everything that is known so far
+ eq2 = eq.subs(res).expand()
+ unsolved_syms = _unsolved_syms(eq2, sort=True)
+ if not unsolved_syms:
+ if res:
+ newresult, delete_res = _append_new_soln(
+ res, None, None, imgset_yes, soln_imageset,
+ original_imageset, newresult, eq2)
+ if delete_res:
+ # `delete_res` is true, means substituting `res` in
+ # eq2 doesn't return `zero` or deleting the `res`
+ # (a soln) since it staisfies expr of `exclude`
+ # list.
+ result.remove(res)
+ continue # skip as it's independent of desired symbols
+ depen1, depen2 = (eq2.rewrite(Add)).as_independent(*unsolved_syms)
+ if (depen1.has(Abs) or depen2.has(Abs)) and solver == solveset_complex:
+ # Absolute values cannot be inverted in the
+ # complex domain
+ continue
+ soln_imageset = {}
+ for sym in unsolved_syms:
+ not_solvable = False
+ try:
+ soln = solver(eq2, sym)
+ total_solvest_call += 1
+ soln_new = S.EmptySet
+ if isinstance(soln, Complement):
+ # separate solution and complement
+ complements[sym] = soln.args[1]
+ soln = soln.args[0]
+ # complement will be added at the end
+ if isinstance(soln, Intersection):
+ # Interval will be at 0th index always
+ if soln.args[0] != Interval(-oo, oo):
+ # sometimes solveset returns soln
+ # with intersection S.Reals, to confirm that
+ # soln is in domain=S.Reals
+ intersections[sym] = soln.args[0]
+ soln_new += soln.args[1]
+ soln = soln_new if soln_new else soln
+ if index > 0 and solver == solveset_real:
+ # one symbol's real soln, another symbol may have
+ # corresponding complex soln.
+ if not isinstance(soln, (ImageSet, ConditionSet)):
+ soln += solveset_complex(eq2, sym) # might give ValueError with Abs
+ except (NotImplementedError, ValueError):
+ # If solveset is not able to solve equation `eq2`. Next
+ # time we may get soln using next equation `eq2`
+ continue
+ if isinstance(soln, ConditionSet):
+ if soln.base_set in (S.Reals, S.Complexes):
+ soln = S.EmptySet
+ # don't do `continue` we may get soln
+ # in terms of other symbol(s)
+ not_solvable = True
+ total_conditionst += 1
+ else:
+ soln = soln.base_set
+
+ if soln is not S.EmptySet:
+ soln, soln_imageset = _extract_main_soln(
+ sym, soln, soln_imageset)
+
+ for sol in soln:
+ # sol is not a `Union` since we checked it
+ # before this loop
+ sol, soln_imageset = _extract_main_soln(
+ sym, sol, soln_imageset)
+ sol = set(sol).pop()
+ free = sol.free_symbols
+ if got_symbol and any(
+ ss in free for ss in got_symbol
+ ):
+ # sol depends on previously solved symbols
+ # then continue
+ continue
+ rnew = res.copy()
+ # put each solution in res and append the new result
+ # in the new result list (solution for symbol `s`)
+ # along with old results.
+ for k, v in res.items():
+ if isinstance(v, Expr) and isinstance(sol, Expr):
+ # if any unsolved symbol is present
+ # Then subs known value
+ rnew[k] = v.subs(sym, sol)
+ # and add this new solution
+ if sol in soln_imageset.keys():
+ # replace all lambda variables with 0.
+ imgst = soln_imageset[sol]
+ rnew[sym] = imgst.lamda(
+ *[0 for i in range(0, len(
+ imgst.lamda.variables))])
+ else:
+ rnew[sym] = sol
+ newresult, delete_res = _append_new_soln(
+ rnew, sym, sol, imgset_yes, soln_imageset,
+ original_imageset, newresult)
+ if delete_res:
+ # deleting the `res` (a soln) since it staisfies
+ # eq of `exclude` list
+ result.remove(res)
+ # solution got for sym
+ if not not_solvable:
+ got_symbol.add(sym)
+ # next time use this new soln
+ if newresult:
+ result = newresult
+ return result, total_solvest_call, total_conditionst
+ # end def _solve_using_know_values()
+
+ new_result_real, solve_call1, cnd_call1 = _solve_using_known_values(
+ old_result, solveset_real)
+ new_result_complex, solve_call2, cnd_call2 = _solve_using_known_values(
+ old_result, solveset_complex)
+
+ # If total_solveset_call is equal to total_conditionset
+ # then solveset failed to solve all of the equations.
+ # In this case we return a ConditionSet here.
+ total_conditionset += (cnd_call1 + cnd_call2)
+ total_solveset_call += (solve_call1 + solve_call2)
+
+ if total_conditionset == total_solveset_call and total_solveset_call != -1:
+ return _return_conditionset(eqs_in_better_order, all_symbols)
+
+ # don't keep duplicate solutions
+ filtered_complex = []
+ for i in list(new_result_complex):
+ for j in list(new_result_real):
+ if i.keys() != j.keys():
+ continue
+ if all(a.dummy_eq(b) for a, b in zip(i.values(), j.values()) \
+ if not (isinstance(a, int) and isinstance(b, int))):
+ break
+ else:
+ filtered_complex.append(i)
+ # overall result
+ result = new_result_real + filtered_complex
+
+ result_all_variables = []
+ result_infinite = []
+ for res in result:
+ if not res:
+ # means {None : None}
+ continue
+ # If length < len(all_symbols) means infinite soln.
+ # Some or all the soln is dependent on 1 symbol.
+ # eg. {x: y+2} then final soln {x: y+2, y: y}
+ if len(res) < len(all_symbols):
+ solved_symbols = res.keys()
+ unsolved = list(filter(
+ lambda x: x not in solved_symbols, all_symbols))
+ for unsolved_sym in unsolved:
+ res[unsolved_sym] = unsolved_sym
+ result_infinite.append(res)
+ if res not in result_all_variables:
+ result_all_variables.append(res)
+
+ if result_infinite:
+ # we have general soln
+ # eg : [{x: -1, y : 1}, {x : -y, y: y}] then
+ # return [{x : -y, y : y}]
+ result_all_variables = result_infinite
+ if intersections or complements:
+ result_all_variables = add_intersection_complement(
+ result_all_variables, intersections, complements)
+
+ # convert to ordered tuple
+ result = S.EmptySet
+ for r in result_all_variables:
+ temp = [r[symb] for symb in all_symbols]
+ result += FiniteSet(tuple(temp))
+ return result
+# end of def substitution()
+
+
+def _solveset_work(system, symbols):
+ soln = solveset(system[0], symbols[0])
+ if isinstance(soln, FiniteSet):
+ _soln = FiniteSet(*[(s,) for s in soln])
+ return _soln
+ else:
+ return FiniteSet(tuple(FiniteSet(soln)))
+
+
+def _handle_positive_dimensional(polys, symbols, denominators):
+ from sympy.polys.polytools import groebner
+ # substitution method where new system is groebner basis of the system
+ _symbols = list(symbols)
+ _symbols.sort(key=default_sort_key)
+ basis = groebner(polys, _symbols, polys=True)
+ new_system = []
+ for poly_eq in basis:
+ new_system.append(poly_eq.as_expr())
+ result = [{}]
+ result = substitution(
+ new_system, symbols, result, [],
+ denominators)
+ return result
+# end of def _handle_positive_dimensional()
+
+
+def _handle_zero_dimensional(polys, symbols, system):
+ # solve 0 dimensional poly system using `solve_poly_system`
+ result = solve_poly_system(polys, *symbols)
+ # May be some extra soln is added because
+ # we used `unrad` in `_separate_poly_nonpoly`, so
+ # need to check and remove if it is not a soln.
+ result_update = S.EmptySet
+ for res in result:
+ dict_sym_value = dict(list(zip(symbols, res)))
+ if all(checksol(eq, dict_sym_value) for eq in system):
+ result_update += FiniteSet(res)
+ return result_update
+# end of def _handle_zero_dimensional()
+
+
+def _separate_poly_nonpoly(system, symbols):
+ polys = []
+ polys_expr = []
+ nonpolys = []
+ # unrad_changed stores a list of expressions containing
+ # radicals that were processed using unrad
+ # this is useful if solutions need to be checked later.
+ unrad_changed = []
+ denominators = set()
+ poly = None
+ for eq in system:
+ # Store denom expressions that contain symbols
+ denominators.update(_simple_dens(eq, symbols))
+ # Convert equality to expression
+ if isinstance(eq, Equality):
+ eq = eq.rewrite(Add)
+ # try to remove sqrt and rational power
+ without_radicals = unrad(simplify(eq), *symbols)
+ if without_radicals:
+ unrad_changed.append(eq)
+ eq_unrad, cov = without_radicals
+ if not cov:
+ eq = eq_unrad
+ if isinstance(eq, Expr):
+ eq = eq.as_numer_denom()[0]
+ poly = eq.as_poly(*symbols, extension=True)
+ elif simplify(eq).is_number:
+ continue
+ if poly is not None:
+ polys.append(poly)
+ polys_expr.append(poly.as_expr())
+ else:
+ nonpolys.append(eq)
+ return polys, polys_expr, nonpolys, denominators, unrad_changed
+# end of def _separate_poly_nonpoly()
+
+
+def _handle_poly(polys, symbols):
+ # _handle_poly(polys, symbols) -> (poly_sol, poly_eqs)
+ #
+ # We will return possible solution information to nonlinsolve as well as a
+ # new system of polynomial equations to be solved if we cannot solve
+ # everything directly here. The new system of polynomial equations will be
+ # a lex-order Groebner basis for the original system. The lex basis
+ # hopefully separate some of the variables and equations and give something
+ # easier for substitution to work with.
+
+ # The format for representing solution sets in nonlinsolve and substitution
+ # is a list of dicts. These are the special cases:
+ no_information = [{}] # No equations solved yet
+ no_solutions = [] # The system is inconsistent and has no solutions.
+
+ # If there is no need to attempt further solution of these equations then
+ # we return no equations:
+ no_equations = []
+
+ inexact = any(not p.domain.is_Exact for p in polys)
+ if inexact:
+ # The use of Groebner over RR is likely to result incorrectly in an
+ # inconsistent Groebner basis. So, convert any float coefficients to
+ # Rational before computing the Groebner basis.
+ polys = [poly(nsimplify(p, rational=True)) for p in polys]
+
+ # Compute a Groebner basis in grevlex order wrt the ordering given. We will
+ # try to convert this to lex order later. Usually it seems to be more
+ # efficient to compute a lex order basis by computing a grevlex basis and
+ # converting to lex with fglm.
+ basis = groebner(polys, symbols, order='grevlex', polys=False)
+
+ #
+ # No solutions (inconsistent equations)?
+ #
+ if 1 in basis:
+
+ # No solutions:
+ poly_sol = no_solutions
+ poly_eqs = no_equations
+
+ #
+ # Finite number of solutions (zero-dimensional case)
+ #
+ elif basis.is_zero_dimensional:
+
+ # Convert Groebner basis to lex ordering
+ basis = basis.fglm('lex')
+
+ # Convert polynomial coefficients back to float before calling
+ # solve_poly_system
+ if inexact:
+ basis = [nfloat(p) for p in basis]
+
+ # Solve the zero-dimensional case using solve_poly_system if possible.
+ # If some polynomials have factors that cannot be solved in radicals
+ # then this will fail. Using solve_poly_system(..., strict=True)
+ # ensures that we either get a complete solution set in radicals or
+ # UnsolvableFactorError will be raised.
+ try:
+ result = solve_poly_system(basis, *symbols, strict=True)
+ except UnsolvableFactorError:
+ # Failure... not fully solvable in radicals. Return the lex-order
+ # basis for substitution to handle.
+ poly_sol = no_information
+ poly_eqs = list(basis)
+ else:
+ # Success! We have a finite solution set and solve_poly_system has
+ # succeeded in finding all solutions. Return the solutions and also
+ # an empty list of remaining equations to be solved.
+ poly_sol = [dict(zip(symbols, res)) for res in result]
+ poly_eqs = no_equations
+
+ #
+ # Infinite families of solutions (positive-dimensional case)
+ #
+ else:
+ # In this case the grevlex basis cannot be converted to lex using the
+ # fglm method and also solve_poly_system cannot solve the equations. We
+ # would like to return a lex basis but since we can't use fglm we
+ # compute the lex basis directly here. The time required to recompute
+ # the basis is generally significantly less than the time required by
+ # substitution to solve the new system.
+ poly_sol = no_information
+ poly_eqs = list(groebner(polys, symbols, order='lex', polys=False))
+
+ if inexact:
+ poly_eqs = [nfloat(p) for p in poly_eqs]
+
+ return poly_sol, poly_eqs
+
+
+def nonlinsolve(system, *symbols):
+ r"""
+ Solve system of $N$ nonlinear equations with $M$ variables, which means both
+ under and overdetermined systems are supported. Positive dimensional
+ system is also supported (A system with infinitely many solutions is said
+ to be positive-dimensional). In a positive dimensional system the solution will
+ be dependent on at least one symbol. Returns both real solution
+ and complex solution (if they exist).
+
+ Parameters
+ ==========
+
+ system : list of equations
+ The target system of equations
+ symbols : list of Symbols
+ symbols should be given as a sequence eg. list
+
+ Returns
+ =======
+
+ A :class:`~.FiniteSet` of ordered tuple of values of `symbols` for which the `system`
+ has solution. Order of values in the tuple is same as symbols present in
+ the parameter `symbols`.
+
+ Please note that general :class:`~.FiniteSet` is unordered, the solution
+ returned here is not simply a :class:`~.FiniteSet` of solutions, rather it
+ is a :class:`~.FiniteSet` of ordered tuple, i.e. the first and only
+ argument to :class:`~.FiniteSet` is a tuple of solutions, which is
+ ordered, and, hence ,the returned solution is ordered.
+
+ Also note that solution could also have been returned as an ordered tuple,
+ FiniteSet is just a wrapper ``{}`` around the tuple. It has no other
+ significance except for the fact it is just used to maintain a consistent
+ output format throughout the solveset.
+
+ For the given set of equations, the respective input types
+ are given below:
+
+ .. math:: xy - 1 = 0
+ .. math:: 4x^2 + y^2 - 5 = 0
+
+ ::
+
+ system = [x*y - 1, 4*x**2 + y**2 - 5]
+ symbols = [x, y]
+
+ Raises
+ ======
+
+ ValueError
+ The input is not valid.
+ The symbols are not given.
+ AttributeError
+ The input symbols are not `Symbol` type.
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, nonlinsolve
+ >>> x, y, z = symbols('x, y, z', real=True)
+ >>> nonlinsolve([x*y - 1, 4*x**2 + y**2 - 5], [x, y])
+ {(-1, -1), (-1/2, -2), (1/2, 2), (1, 1)}
+
+ 1. Positive dimensional system and complements:
+
+ >>> from sympy import pprint
+ >>> from sympy.polys.polytools import is_zero_dimensional
+ >>> a, b, c, d = symbols('a, b, c, d', extended_real=True)
+ >>> eq1 = a + b + c + d
+ >>> eq2 = a*b + b*c + c*d + d*a
+ >>> eq3 = a*b*c + b*c*d + c*d*a + d*a*b
+ >>> eq4 = a*b*c*d - 1
+ >>> system = [eq1, eq2, eq3, eq4]
+ >>> is_zero_dimensional(system)
+ False
+ >>> pprint(nonlinsolve(system, [a, b, c, d]), use_unicode=False)
+ -1 1 1 -1
+ {(---, -d, -, {d} \ {0}), (-, -d, ---, {d} \ {0})}
+ d d d d
+ >>> nonlinsolve([(x+y)**2 - 4, x + y - 2], [x, y])
+ {(2 - y, y)}
+
+ 2. If some of the equations are non-polynomial then `nonlinsolve`
+ will call the ``substitution`` function and return real and complex solutions,
+ if present.
+
+ >>> from sympy import exp, sin
+ >>> nonlinsolve([exp(x) - sin(y), y**2 - 4], [x, y])
+ {(ImageSet(Lambda(_n, I*(2*_n*pi + pi) + log(sin(2))), Integers), -2),
+ (ImageSet(Lambda(_n, 2*_n*I*pi + log(sin(2))), Integers), 2)}
+
+ 3. If system is non-linear polynomial and zero-dimensional then it
+ returns both solution (real and complex solutions, if present) using
+ :func:`~.solve_poly_system`:
+
+ >>> from sympy import sqrt
+ >>> nonlinsolve([x**2 - 2*y**2 -2, x*y - 2], [x, y])
+ {(-2, -1), (2, 1), (-sqrt(2)*I, sqrt(2)*I), (sqrt(2)*I, -sqrt(2)*I)}
+
+ 4. ``nonlinsolve`` can solve some linear (zero or positive dimensional)
+ system (because it uses the :func:`sympy.polys.polytools.groebner` function to get the
+ groebner basis and then uses the ``substitution`` function basis as the
+ new `system`). But it is not recommended to solve linear system using
+ ``nonlinsolve``, because :func:`~.linsolve` is better for general linear systems.
+
+ >>> nonlinsolve([x + 2*y -z - 3, x - y - 4*z + 9, y + z - 4], [x, y, z])
+ {(3*z - 5, 4 - z, z)}
+
+ 5. System having polynomial equations and only real solution is
+ solved using :func:`~.solve_poly_system`:
+
+ >>> e1 = sqrt(x**2 + y**2) - 10
+ >>> e2 = sqrt(y**2 + (-x + 10)**2) - 3
+ >>> nonlinsolve((e1, e2), (x, y))
+ {(191/20, -3*sqrt(391)/20), (191/20, 3*sqrt(391)/20)}
+ >>> nonlinsolve([x**2 + 2/y - 2, x + y - 3], [x, y])
+ {(1, 2), (1 - sqrt(5), 2 + sqrt(5)), (1 + sqrt(5), 2 - sqrt(5))}
+ >>> nonlinsolve([x**2 + 2/y - 2, x + y - 3], [y, x])
+ {(2, 1), (2 - sqrt(5), 1 + sqrt(5)), (2 + sqrt(5), 1 - sqrt(5))}
+
+ 6. It is better to use symbols instead of trigonometric functions or
+ :class:`~.Function`. For example, replace $\sin(x)$ with a symbol, replace
+ $f(x)$ with a symbol and so on. Get a solution from ``nonlinsolve`` and then
+ use :func:`~.solveset` to get the value of $x$.
+
+ How nonlinsolve is better than old solver ``_solve_system`` :
+ =============================================================
+
+ 1. A positive dimensional system solver: nonlinsolve can return
+ solution for positive dimensional system. It finds the
+ Groebner Basis of the positive dimensional system(calling it as
+ basis) then we can start solving equation(having least number of
+ variable first in the basis) using solveset and substituting that
+ solved solutions into other equation(of basis) to get solution in
+ terms of minimum variables. Here the important thing is how we
+ are substituting the known values and in which equations.
+
+ 2. Real and complex solutions: nonlinsolve returns both real
+ and complex solution. If all the equations in the system are polynomial
+ then using :func:`~.solve_poly_system` both real and complex solution is returned.
+ If all the equations in the system are not polynomial equation then goes to
+ ``substitution`` method with this polynomial and non polynomial equation(s),
+ to solve for unsolved variables. Here to solve for particular variable
+ solveset_real and solveset_complex is used. For both real and complex
+ solution ``_solve_using_known_values`` is used inside ``substitution``
+ (``substitution`` will be called when any non-polynomial equation is present).
+ If a solution is valid its general solution is added to the final result.
+
+ 3. :class:`~.Complement` and :class:`~.Intersection` will be added:
+ nonlinsolve maintains dict for complements and intersections. If solveset
+ find complements or/and intersections with any interval or set during the
+ execution of ``substitution`` function, then complement or/and
+ intersection for that variable is added before returning final solution.
+
+ """
+ if not system:
+ return S.EmptySet
+
+ if not symbols:
+ msg = ('Symbols must be given, for which solution of the '
+ 'system is to be found.')
+ raise ValueError(filldedent(msg))
+
+ if hasattr(symbols[0], '__iter__'):
+ symbols = symbols[0]
+
+ if not is_sequence(symbols) or not symbols:
+ msg = ('Symbols must be given, for which solution of the '
+ 'system is to be found.')
+ raise IndexError(filldedent(msg))
+
+ symbols = list(map(_sympify, symbols))
+ system, symbols, swap = recast_to_symbols(system, symbols)
+ if swap:
+ soln = nonlinsolve(system, symbols)
+ return FiniteSet(*[tuple(i.xreplace(swap) for i in s) for s in soln])
+
+ if len(system) == 1 and len(symbols) == 1:
+ return _solveset_work(system, symbols)
+
+ # main code of def nonlinsolve() starts from here
+
+ polys, polys_expr, nonpolys, denominators, unrad_changed = \
+ _separate_poly_nonpoly(system, symbols)
+
+ poly_eqs = []
+ poly_sol = [{}]
+
+ if polys:
+ poly_sol, poly_eqs = _handle_poly(polys, symbols)
+ if poly_sol and poly_sol[0]:
+ poly_syms = set().union(*(eq.free_symbols for eq in polys))
+ unrad_syms = set().union(*(eq.free_symbols for eq in unrad_changed))
+ if unrad_syms == poly_syms and unrad_changed:
+ # if all the symbols have been solved by _handle_poly
+ # and unrad has been used then check solutions
+ poly_sol = [sol for sol in poly_sol if checksol(unrad_changed, sol)]
+
+ # Collect together the unsolved polynomials with the non-polynomial
+ # equations.
+ remaining = poly_eqs + nonpolys
+
+ # to_tuple converts a solution dictionary to a tuple containing the
+ # value for each symbol
+ to_tuple = lambda sol: tuple(sol[s] for s in symbols)
+
+ if not remaining:
+ # If there is nothing left to solve then return the solution from
+ # solve_poly_system directly.
+ return FiniteSet(*map(to_tuple, poly_sol))
+ else:
+ # Here we handle:
+ #
+ # 1. The Groebner basis if solve_poly_system failed.
+ # 2. The Groebner basis in the positive-dimensional case.
+ # 3. Any non-polynomial equations
+ #
+ # If solve_poly_system did succeed then we pass those solutions in as
+ # preliminary results.
+ subs_res = substitution(remaining, symbols, result=poly_sol, exclude=denominators)
+
+ if not isinstance(subs_res, FiniteSet):
+ return subs_res
+
+ # check solutions produced by substitution. Currently, checking is done for
+ # only those solutions which have non-Set variable values.
+ if unrad_changed:
+ result = [dict(zip(symbols, sol)) for sol in subs_res.args]
+ correct_sols = [sol for sol in result if any(isinstance(v, Set) for v in sol)
+ or checksol(unrad_changed, sol) != False]
+ return FiniteSet(*map(to_tuple, correct_sols))
+ else:
+ return subs_res