|
|
"""Tests for solvers of systems of polynomial equations. """ |
|
|
from sympy.core.numbers import (I, Integer, Rational) |
|
|
from sympy.core.singleton import S |
|
|
from sympy.core.symbol import symbols |
|
|
from sympy.functions.elementary.miscellaneous import sqrt |
|
|
from sympy.polys.domains.rationalfield import QQ |
|
|
from sympy.polys.polyerrors import UnsolvableFactorError |
|
|
from sympy.polys.polyoptions import Options |
|
|
from sympy.polys.polytools import Poly |
|
|
from sympy.solvers.solvers import solve |
|
|
from sympy.utilities.iterables import flatten |
|
|
from sympy.abc import x, y, z |
|
|
from sympy.polys import PolynomialError |
|
|
from sympy.solvers.polysys import (solve_poly_system, |
|
|
solve_triangulated, |
|
|
solve_biquadratic, SolveFailed, |
|
|
solve_generic) |
|
|
from sympy.polys.polytools import parallel_poly_from_expr |
|
|
from sympy.testing.pytest import raises |
|
|
|
|
|
|
|
|
def test_solve_poly_system(): |
|
|
assert solve_poly_system([x - 1], x) == [(S.One,)] |
|
|
|
|
|
assert solve_poly_system([y - x, y - x - 1], x, y) is None |
|
|
|
|
|
assert solve_poly_system([y - x**2, y + x**2], x, y) == [(S.Zero, S.Zero)] |
|
|
|
|
|
assert solve_poly_system([2*x - 3, y*Rational(3, 2) - 2*x, z - 5*y], x, y, z) == \ |
|
|
[(Rational(3, 2), Integer(2), Integer(10))] |
|
|
|
|
|
assert solve_poly_system([x*y - 2*y, 2*y**2 - x**2], x, y) == \ |
|
|
[(0, 0), (2, -sqrt(2)), (2, sqrt(2))] |
|
|
|
|
|
assert solve_poly_system([y - x**2, y + x**2 + 1], x, y) == \ |
|
|
[(-I*sqrt(S.Half), Rational(-1, 2)), (I*sqrt(S.Half), Rational(-1, 2))] |
|
|
|
|
|
f_1 = x**2 + y + z - 1 |
|
|
f_2 = x + y**2 + z - 1 |
|
|
f_3 = x + y + z**2 - 1 |
|
|
|
|
|
a, b = sqrt(2) - 1, -sqrt(2) - 1 |
|
|
|
|
|
assert solve_poly_system([f_1, f_2, f_3], x, y, z) == \ |
|
|
[(0, 0, 1), (0, 1, 0), (1, 0, 0), (a, a, a), (b, b, b)] |
|
|
|
|
|
solution = [(1, -1), (1, 1)] |
|
|
|
|
|
assert solve_poly_system([Poly(x**2 - y**2), Poly(x - 1)]) == solution |
|
|
assert solve_poly_system([x**2 - y**2, x - 1], x, y) == solution |
|
|
assert solve_poly_system([x**2 - y**2, x - 1]) == solution |
|
|
|
|
|
assert solve_poly_system( |
|
|
[x + x*y - 3, y + x*y - 4], x, y) == [(-3, -2), (1, 2)] |
|
|
|
|
|
raises(NotImplementedError, lambda: solve_poly_system([x**3 - y**3], x, y)) |
|
|
raises(NotImplementedError, lambda: solve_poly_system( |
|
|
[z, -2*x*y**2 + x + y**2*z, y**2*(-z - 4) + 2])) |
|
|
raises(PolynomialError, lambda: solve_poly_system([1/x], x)) |
|
|
|
|
|
raises(NotImplementedError, lambda: solve_poly_system( |
|
|
[x-1,], (x, y))) |
|
|
raises(NotImplementedError, lambda: solve_poly_system( |
|
|
[y-1,], (x, y))) |
|
|
|
|
|
|
|
|
|
|
|
assert solve_poly_system([x**5 - x + 1], [x], strict=False) == [] |
|
|
raises(UnsolvableFactorError, lambda: solve_poly_system( |
|
|
[x**5 - x + 1], [x], strict=True)) |
|
|
|
|
|
assert solve_poly_system([(x - 1)*(x**5 - x + 1), y**2 - 1], [x, y], |
|
|
strict=False) == [(1, -1), (1, 1)] |
|
|
raises(UnsolvableFactorError, |
|
|
lambda: solve_poly_system([(x - 1)*(x**5 - x + 1), y**2-1], |
|
|
[x, y], strict=True)) |
|
|
|
|
|
|
|
|
def test_solve_generic(): |
|
|
NewOption = Options((x, y), {'domain': 'ZZ'}) |
|
|
assert solve_generic([x**2 - 2*y**2, y**2 - y + 1], NewOption) == \ |
|
|
[(-sqrt(-1 - sqrt(3)*I), Rational(1, 2) - sqrt(3)*I/2), |
|
|
(sqrt(-1 - sqrt(3)*I), Rational(1, 2) - sqrt(3)*I/2), |
|
|
(-sqrt(-1 + sqrt(3)*I), Rational(1, 2) + sqrt(3)*I/2), |
|
|
(sqrt(-1 + sqrt(3)*I), Rational(1, 2) + sqrt(3)*I/2)] |
|
|
|
|
|
|
|
|
|
|
|
assert solve_generic( |
|
|
[2*x - y, (y - 1)*(y**5 - y + 1)], NewOption, strict=False) == \ |
|
|
[(Rational(1, 2), 1)] |
|
|
raises(UnsolvableFactorError, lambda: solve_generic( |
|
|
[2*x - y, (y - 1)*(y**5 - y + 1)], NewOption, strict=True)) |
|
|
|
|
|
|
|
|
def test_solve_biquadratic(): |
|
|
x0, y0, x1, y1, r = symbols('x0 y0 x1 y1 r') |
|
|
|
|
|
f_1 = (x - 1)**2 + (y - 1)**2 - r**2 |
|
|
f_2 = (x - 2)**2 + (y - 2)**2 - r**2 |
|
|
s = sqrt(2*r**2 - 1) |
|
|
a = (3 - s)/2 |
|
|
b = (3 + s)/2 |
|
|
assert solve_poly_system([f_1, f_2], x, y) == [(a, b), (b, a)] |
|
|
|
|
|
f_1 = (x - 1)**2 + (y - 2)**2 - r**2 |
|
|
f_2 = (x - 1)**2 + (y - 1)**2 - r**2 |
|
|
|
|
|
assert solve_poly_system([f_1, f_2], x, y) == \ |
|
|
[(1 - sqrt((2*r - 1)*(2*r + 1))/2, Rational(3, 2)), |
|
|
(1 + sqrt((2*r - 1)*(2*r + 1))/2, Rational(3, 2))] |
|
|
|
|
|
query = lambda expr: expr.is_Pow and expr.exp is S.Half |
|
|
|
|
|
f_1 = (x - 1 )**2 + (y - 2)**2 - r**2 |
|
|
f_2 = (x - x1)**2 + (y - 1)**2 - r**2 |
|
|
|
|
|
result = solve_poly_system([f_1, f_2], x, y) |
|
|
|
|
|
assert len(result) == 2 and all(len(r) == 2 for r in result) |
|
|
assert all(r.count(query) == 1 for r in flatten(result)) |
|
|
|
|
|
f_1 = (x - x0)**2 + (y - y0)**2 - r**2 |
|
|
f_2 = (x - x1)**2 + (y - y1)**2 - r**2 |
|
|
|
|
|
result = solve_poly_system([f_1, f_2], x, y) |
|
|
|
|
|
assert len(result) == 2 and all(len(r) == 2 for r in result) |
|
|
assert all(len(r.find(query)) == 1 for r in flatten(result)) |
|
|
|
|
|
s1 = (x*y - y, x**2 - x) |
|
|
assert solve(s1) == [{x: 1}, {x: 0, y: 0}] |
|
|
s2 = (x*y - x, y**2 - y) |
|
|
assert solve(s2) == [{y: 1}, {x: 0, y: 0}] |
|
|
gens = (x, y) |
|
|
for seq in (s1, s2): |
|
|
(f, g), opt = parallel_poly_from_expr(seq, *gens) |
|
|
raises(SolveFailed, lambda: solve_biquadratic(f, g, opt)) |
|
|
seq = (x**2 + y**2 - 2, y**2 - 1) |
|
|
(f, g), opt = parallel_poly_from_expr(seq, *gens) |
|
|
assert solve_biquadratic(f, g, opt) == [ |
|
|
(-1, -1), (-1, 1), (1, -1), (1, 1)] |
|
|
ans = [(0, -1), (0, 1)] |
|
|
seq = (x**2 + y**2 - 1, y**2 - 1) |
|
|
(f, g), opt = parallel_poly_from_expr(seq, *gens) |
|
|
assert solve_biquadratic(f, g, opt) == ans |
|
|
seq = (x**2 + y**2 - 1, x**2 - x + y**2 - 1) |
|
|
(f, g), opt = parallel_poly_from_expr(seq, *gens) |
|
|
assert solve_biquadratic(f, g, opt) == ans |
|
|
|
|
|
|
|
|
def test_solve_triangulated(): |
|
|
f_1 = x**2 + y + z - 1 |
|
|
f_2 = x + y**2 + z - 1 |
|
|
f_3 = x + y + z**2 - 1 |
|
|
|
|
|
a, b = sqrt(2) - 1, -sqrt(2) - 1 |
|
|
|
|
|
assert solve_triangulated([f_1, f_2, f_3], x, y, z) == \ |
|
|
[(0, 0, 1), (0, 1, 0), (1, 0, 0)] |
|
|
|
|
|
dom = QQ.algebraic_field(sqrt(2)) |
|
|
|
|
|
assert solve_triangulated([f_1, f_2, f_3], x, y, z, domain=dom) == \ |
|
|
[(0, 0, 1), (0, 1, 0), (1, 0, 0), (a, a, a), (b, b, b)] |
|
|
|
|
|
|
|
|
def test_solve_issue_3686(): |
|
|
roots = solve_poly_system([((x - 5)**2/250000 + (y - Rational(5, 10))**2/250000) - 1, x], x, y) |
|
|
assert roots == [(0, S.Half - 15*sqrt(1111)), (0, S.Half + 15*sqrt(1111))] |
|
|
|
|
|
roots = solve_poly_system([((x - 5)**2/250000 + (y - 5.0/10)**2/250000) - 1, x], x, y) |
|
|
|
|
|
assert len(roots) == 2 |
|
|
assert roots[0][0] == 0 |
|
|
assert roots[0][1].epsilon_eq(-499.474999374969, 1e12) |
|
|
assert roots[1][0] == 0 |
|
|
assert roots[1][1].epsilon_eq(500.474999374969, 1e12) |
|
|
|
