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) == None
assert solve_poly_system([y - x**2, y + x**2], x, y) == [(S.Zero, S.Zero)]
assert solve_poly_system([2*x - 3, 3*y/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, -2**S.Half), (2, 2**S.Half)]
assert solve_poly_system([y - x**2, y + x**2 + 1], x, y) == \
[(I*S.Half**S.Half, -S.Half), (-I*S.Half**S.Half, -S.Half)]
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) == \
[(a, a, a), (0, 0, 1), (0, 1, 0), (b, b, b), (1, 0, 0)]
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
raises(NotImplementedError, "solve_poly_system([x**3-y**3], x, y)")
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) == None
assert solve_poly_system([y - x**2, y + x**2], x, y) == [(S.Zero, S.Zero)]
assert solve_poly_system([2*x - 3, 3*y/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, -2**S.Half), (2, 2**S.Half)]
assert solve_poly_system([y - x**2, y + x**2 + 1], x, y) == \
[(I*S.Half**S.Half, -S.Half), (-I*S.Half**S.Half, -S.Half)]
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) == \
[(a, a, a), (0, 0, 1), (0, 1, 0), (b, b, b), (1, 0, 0)]
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
raises(NotImplementedError, "solve_poly_system([x**3-y**3], x, y)")
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
assert solve_poly_system([f_1, f_2], x, y) == \
[(S(3)/2 + sqrt(-1 + 2*r**2)/2, S(3)/2 - sqrt(-1 + 2*r**2)/2),
(S(3)/2 - sqrt(-1 + 2*r**2)/2, S(3)/2 + sqrt(-1 + 2*r**2)/2)]
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, S(3)/2),
(1 - sqrt(((2*r - 1)*(2*r + 1)))/2, S(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))
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
assert solve_poly_system([f_1, f_2], x, y) == \
[(S(3)/2 + (-1 + 2*r**2)**(S(1)/2)/2, S(3)/2 - (-1 + 2*r**2)**(S(1)/2)/2),
(S(3)/2 - (-1 + 2*r**2)**(S(1)/2)/2, S(3)/2 + (-1 + 2*r**2)**(S(1)/2)/2)]
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 + (((2*r - 1)*(2*r + 1)))**(S(1)/2)/2, S(3)/2),
(1 - (((2*r - 1)*(2*r + 1)))**(S(1)/2)/2, S(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))
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_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)
# TODO: does this really have to be so complicated?!
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)
def test_solve_issue_3686():
roots = solve_poly_system([((x - 5)**2/250000 + (y - S(5)/10)**2/250000) - 1, x], x, y)
assert roots == [(0, S(1)/2 + 15*sqrt(1111)), (0, S(1)/2 - 15*sqrt(1111))]
roots = solve_poly_system([((x - 5)**2/250000 + (y - 5.0/10)**2/250000) - 1, x], x, y)
# TODO: does this really have to be so complicated?!
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)
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, S(3)/2),
(1 + sqrt(((2*r - 1)*(2*r + 1)))/2, S(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_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)))
# solve_poly_system should ideally construct solutions using
# CRootOf for the following four tests
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 solve(f, *symbols, **flags):
"""Solves equations and systems of equations.
Currently supported are univariate polynomial, transcendental
equations, piecewise combinations thereof and systems of linear
and polynomial equations. Input is formed as a single expression
or an equation, or an iterable container in case of an equation
system. The type of output may vary and depends heavily on the
input. For more details refer to more problem specific functions.
By default all solutions are simplified to make the output more
readable. If this is not the expected behavior (e.g., because of
speed issues) set simplified=False in function arguments.
To solve equations and systems of equations like recurrence relations
or differential equations, use rsolve() or dsolve(), respectively.
>>> from sympy import I, solve
>>> from sympy.abc import x, y
Solve a polynomial equation:
>>> solve(x**4-1, x)
[1, -1, -I, I]
Solve a linear system:
>>> solve((x+5*y-2, -3*x+6*y-15), x, y)
{x: -3, y: 1}
"""
def sympit(w):
return map(sympify, iff(isinstance(w, (list, tuple, set)), w, [w]))
# make f and symbols into lists of sympified quantities
# keeping track of how f was passed since if it is a list
# a dictionary of results will be returned.
bare_f = not isinstance(f, (list, tuple, set))
f, symbols = (sympit(w) for w in [f, symbols])
if any(isinstance(fi, bool) or (fi.is_Relational and not fi.is_Equality) for fi in f):
return reduce_inequalities(f, assume=flags.get("assume"))
for i, fi in enumerate(f):
if fi.is_Equality:
f[i] = fi.lhs - fi.rhs
if not symbols:
# get symbols from equations or supply dummy symbols since
# solve(3,x) returns []...though it seems that it should raise some sort of error TODO
symbols = set([])
for fi in f:
symbols |= fi.atoms(Symbol) or set([Dummy("x")])
symbols = list(symbols)
if bare_f:
f = f[0]
if len(symbols) == 1:
if isinstance(symbols[0], (list, tuple, set)):
symbols = symbols[0]
result = list()
# Begin code handling for Function and Derivative instances
# Basic idea: store all the passed symbols in symbols_passed, check to see
# if any of them are Function or Derivative types, if so, use a dummy
# symbol in their place, and set symbol_swapped = True so that other parts
# of the code can be aware of the swap. Once all swapping is done, the
# continue on with regular solving as usual, and swap back at the end of
# the routine, so that whatever was passed in symbols is what is returned.
symbols_new = []
symbol_swapped = False
symbols_passed = list(symbols)
for i, s in enumerate(symbols):
if s.is_Symbol:
s_new = s
elif s.is_Function:
symbol_swapped = True
s_new = Dummy("F%d" % i)
elif s.is_Derivative:
symbol_swapped = True
s_new = Dummy("D%d" % i)
else:
raise TypeError("not a Symbol or a Function")
symbols_new.append(s_new)
if symbol_swapped:
swap_back_dict = dict(zip(symbols_new, symbols))
# End code for handling of Function and Derivative instances
if not isinstance(f, (tuple, list, set)):
# Create a swap dictionary for storing the passed symbols to be solved
# for, so that they may be swapped back.
if symbol_swapped:
swap_dict = zip(symbols, symbols_new)
f = f.subs(swap_dict)
symbols = symbols_new
# Any embedded piecewise functions need to be brought out to the
# top level so that the appropriate strategy gets selected.
f = piecewise_fold(f)
if len(symbols) != 1:
result = {}
for s in symbols:
result[s] = solve(f, s, **flags)
if flags.get("simplified", True):
for s, r in result.items():
result[s] = map(simplify, r)
return result
symbol = symbols[0]
strategy = guess_solve_strategy(f, symbol)
if strategy == GS_POLY:
poly = f.as_poly(symbol)
if poly is None:
raise NotImplementedError("Cannot solve equation " + str(f) + " for " + str(symbol))
# for cubics and quartics, if the flag wasn't set, DON'T do it
# by default since the results are quite long. Perhaps one could
# base this decision on a certain crtical length of the roots.
if poly.degree > 2:
flags["simplified"] = flags.get("simplified", False)
result = roots(poly, cubics=True, quartics=True).keys()
elif strategy == GS_RATIONAL:
P, Q = f.as_numer_denom()
# TODO: check for Q != 0
result = solve(P, symbol, **flags)
elif strategy == GS_POLY_CV_1:
args = list(f.args)
if isinstance(f, Add):
# we must search for a suitable change of variable
# collect exponents
exponents_denom = list()
for arg in args:
if isinstance(arg, Pow):
exponents_denom.append(arg.exp.q)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
exponents_denom.append(mul_arg.exp.q)
assert len(exponents_denom) > 0
if len(exponents_denom) == 1:
m = exponents_denom[0]
else:
# get the LCM of the denominators
m = reduce(ilcm, exponents_denom)
# x -> y**m.
# we assume positive for simplification purposes
t = Dummy("t", positive=True)
f_ = f.subs(symbol, t ** m)
if guess_solve_strategy(f_, t) != GS_POLY:
raise NotImplementedError("Could not convert to a polynomial equation: %s" % f_)
cv_sols = solve(f_, t)
for sol in cv_sols:
result.append(sol ** m)
elif isinstance(f, Mul):
for mul_arg in args:
result.extend(solve(mul_arg, symbol))
elif strategy == GS_POLY_CV_2:
m = 0
args = list(f.args)
if isinstance(f, Add):
for arg in args:
if isinstance(arg, Pow):
m = min(m, arg.exp)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
elif isinstance(f, Mul):
for mul_arg in args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
f1 = simplify(f * symbol ** (-m))
result = solve(f1, symbol)
# TODO: we might have introduced unwanted solutions
# when multiplied by x**-m
elif strategy == GS_PIECEWISE:
result = set()
for expr, cond in f.args:
candidates = solve(expr, *symbols)
if isinstance(cond, bool) or cond.is_Number:
if not cond:
continue
# Only include solutions that do not match the condition
# of any of the other pieces.
for candidate in candidates:
matches_other_piece = False
for other_expr, other_cond in f.args:
if isinstance(other_cond, bool) or other_cond.is_Number:
continue
if bool(other_cond.subs(symbol, candidate)):
matches_other_piece = True
break
if not matches_other_piece:
result.add(candidate)
else:
for candidate in candidates:
if bool(cond.subs(symbol, candidate)):
result.add(candidate)
result = list(result)
elif strategy == GS_TRANSCENDENTAL:
# a, b = f.as_numer_denom()
# Let's throw away the denominator for now. When we have robust
# assumptions, it should be checked, that for the solution,
# b!=0.
result = tsolve(f, *symbols)
elif strategy == -1:
raise ValueError("Could not parse expression %s" % f)
else:
raise NotImplementedError("No algorithms are implemented to solve equation %s" % f)
# This symbol swap should not be necessary for the single symbol case: if you've
# solved for the symbol the it will not appear in the solution. Right now, however
# ode's are getting solutions for solve (even though they shouldn't be -- see the
# swap_back test in test_solvers).
if symbol_swapped:
result = [ri.subs(swap_back_dict) for ri in result]
if flags.get("simplified", True) and strategy != GS_RATIONAL:
return map(simplify, result)
else:
return result
else:
if not f:
return {}
else:
# Create a swap dictionary for storing the passed symbols to be
# solved for, so that they may be swapped back.
if symbol_swapped:
swap_dict = zip(symbols, symbols_new)
f = [fi.subs(swap_dict) for fi in f]
symbols = symbols_new
polys = []
for g in f:
poly = g.as_poly(*symbols)
if poly is not None:
polys.append(poly)
else:
raise NotImplementedError()
if all(p.is_linear for p in polys):
n, m = len(f), len(symbols)
matrix = zeros((n, m + 1))
for i, poly in enumerate(polys):
for monom, coeff in poly.terms():
try:
j = list(monom).index(1)
matrix[i, j] = coeff
except ValueError:
matrix[i, m] = -coeff
soln = solve_linear_system(matrix, *symbols, **flags)
else:
soln = solve_poly_system(polys)
# Use swap_dict to ensure we return the same type as what was
# passed
if symbol_swapped:
if isinstance(soln, dict):
res = {}
for k in soln.keys():
res.update({swap_back_dict[k]: soln[k]})
return res
else:
return soln
else:
return soln
def _solve(f, *symbols, **flags):
""" Return a checked solution for f in terms of one or more of the symbols."""
if not iterable(f):
if len(symbols) != 1:
soln = None
free = f.free_symbols
ex = free - set(symbols)
if len(ex) == 1:
ex = ex.pop()
try:
# may come back as dict or list (if non-linear)
soln = solve_undetermined_coeffs(f, symbols, ex)
except NotImplementedError:
pass
if not soln is None:
return soln
# find first successful solution
failed = []
for s in symbols:
n, d = solve_linear(f, x=[s])
if n.is_Symbol:
soln = {n: cancel(d)}
return soln
failed.append(s)
for s in failed:
try:
soln = _solve(f, s, **flags)
return soln
except NotImplementedError:
pass
else:
msg = "No algorithms are implemented to solve equation %s"
raise NotImplementedError(msg % f)
symbol = symbols[0]
# first see if it really depends on symbol and whether there
# is a linear solution
f_num, sol = solve_linear(f, x=symbols)
if not symbol in f_num.free_symbols:
return []
elif f_num.is_Symbol:
return [cancel(sol)]
strategy = guess_solve_strategy(f, symbol)
result = False # no solution was obtained
if strategy == GS_POLY:
poly = f.as_poly(symbol)
if poly is None:
msg = "Cannot solve equation %s for %s" % (f, symbol)
else:
# for cubics and quartics, if the flag wasn't set, DON'T do it
# by default since the results are quite long. Perhaps one could
# base this decision on a certain critical length of the roots.
if poly.degree() > 2:
flags['simplified'] = flags.get('simplified', False)
result = roots(poly, cubics=True, quartics=True).keys()
elif strategy == GS_RATIONAL:
P, _ = f.as_numer_denom()
dens = denoms(f, x=symbols)
try:
soln = _solve(P, symbol, **flags)
except NotImplementedError:
msg = "Cannot solve equation %s for %s" % (P, symbol)
result = []
else:
if dens:
# reject any result that makes any denom. affirmatively 0;
# if in doubt, keep it
result = [s for s in soln if all(not checksol(den, {symbol: s}, **flags) for den in dens)]
else:
result = soln
elif strategy == GS_POLY_CV_1:
args = list(f.args)
if isinstance(f, Pow):
result = _solve(args[0], symbol, **flags)
elif isinstance(f, Add):
# we must search for a suitable change of variables
# collect exponents
exponents_denom = list()
for arg in args:
if isinstance(arg, Pow):
exponents_denom.append(arg.exp.q)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
exponents_denom.append(mul_arg.exp.q)
assert len(exponents_denom) > 0
if len(exponents_denom) == 1:
m = exponents_denom[0]
else:
# get the LCM of the denominators
m = reduce(ilcm, exponents_denom)
# x -> y**m.
# we assume positive for simplification purposes
t = Dummy('t', positive=True)
f_ = f.subs(symbol, t**m)
if guess_solve_strategy(f_, t) != GS_POLY:
msg = "Could not convert to a polynomial equation: %s" % f_
result = []
else:
soln = [s**m for s in _solve(f_, t)]
# we might have introduced solutions from another branch
# when changing variables; check and keep solutions
# unless they definitely aren't a solution
result = [s for s in soln if checksol(f, {symbol: s}, **flags) is not False]
elif isinstance(f, Mul):
result = []
for m in f.args:
result.extend(_solve(m, symbol, **flags) or [])
elif strategy == GS_POLY_CV_2:
m = 0
args = list(f.args)
if isinstance(f, Add):
for arg in args:
if isinstance(arg, Pow):
m = min(m, arg.exp)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
elif isinstance(f, Mul):
for mul_arg in args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
if m and m != 1:
f_ = simplify(f*symbol**(-m))
try:
sols = _solve(f_, symbol)
except NotImplementedError:
msg = 'Could not solve %s for %s' % (f_, symbol)
else:
# we might have introduced unwanted solutions
# when multiplying by x**-m; check and keep solutions
# unless they definitely aren't a solution
if sols:
result = [s for s in sols if checksol(f, {symbol: s}, **flags) is not False]
else:
msg = 'CV_2 calculated %d but it should have been other than 0 or 1' % m
elif strategy == GS_PIECEWISE:
result = set()
for expr, cond in f.args:
candidates = _solve(expr, *symbols)
if isinstance(cond, bool) or cond.is_Number:
if not cond:
continue
# Only include solutions that do not match the condition
# of any of the other pieces.
for candidate in candidates:
matches_other_piece = False
for other_expr, other_cond in f.args:
if isinstance(other_cond, bool) \
or other_cond.is_Number:
continue
if bool(other_cond.subs(symbol, candidate)):
matches_other_piece = True
break
if not matches_other_piece:
result.add(candidate)
else:
for candidate in candidates:
if bool(cond.subs(symbol, candidate)):
result.add(candidate)
result = list(result)
elif strategy == -1:
raise ValueError('Could not parse expression %s' % f)
# this is the fallback for not getting any other solution
if result is False or strategy == GS_TRANSCENDENTAL:
soln = tsolve(f_num, symbol)
dens = denoms(f, x=symbols)
if not dens:
result = soln
else:
# reject any result that makes any denom. affirmatively 0;
# if in doubt, keep it
result = [s for s in soln if all(not checksol(den, {symbol: s}, **flags) for den in dens)]
if result is False:
raise NotImplementedError(msg + "\nNo algorithms are implemented to solve equation %s" % f)
if flags.get('simplified', True) and strategy != GS_RATIONAL:
result = map(simplify, result)
return result
else:
if not f:
return []
else:
polys = []
for g in f:
poly = g.as_poly(*symbols, **{'extension': True})
if poly is not None:
polys.append(poly)
else:
raise NotImplementedError()
if all(p.is_linear for p in polys):
n, m = len(f), len(symbols)
matrix = zeros((n, m + 1))
for i, poly in enumerate(polys):
for monom, coeff in poly.terms():
try:
j = list(monom).index(1)
matrix[i, j] = coeff
except ValueError:
matrix[i, m] = -coeff
# a dictionary of symbols: values or None
result = solve_linear_system(matrix, *symbols, **flags)
return result
else:
# a list of tuples, T, where T[i] [j] corresponds to the ith solution for symbols[j]
result = solve_poly_system(polys)
return result
def solve(f, *symbols, **flags):
"""Solves equations and systems of equations.
Currently supported are univariate polynomial and transcendental
equations and systems of linear and polynomial equations. Input
is formed as a single expression or an equation, or an iterable
container in case of an equation system. The type of output may
vary and depends heavily on the input. For more details refer to
more problem specific functions.
By default all solutions are simplified to make the output more
readable. If this is not the expected behavior, eg. because of
speed issues, set simplified=False in function arguments.
To solve equations and systems of equations of other kind, eg.
recurrence relations of differential equations use rsolve() or
dsolve() functions respectively.
>>> from sympy import *
>>> x,y = symbols('xy')
Solve a polynomial equation:
>>> solve(x**4-1, x)
[1, -1, -I, I]
Solve a linear system:
>>> solve((x+5*y-2, -3*x+6*y-15), x, y)
{x: -3, y: 1}
"""
if not symbols:
raise ValueError('no symbols were given')
if len(symbols) == 1:
if isinstance(symbols[0], (list, tuple, set)):
symbols = symbols[0]
symbols = map(sympify, symbols)
result = list()
# Begin code handling for Function and Derivative instances
# Basic idea: store all the passed symbols in symbols_passed, check to see
# if any of them are Function or Derivative types, if so, use a dummy
# symbol in their place, and set symbol_swapped = True so that other parts
# of the code can be aware of the swap. Once all swapping is done, the
# continue on with regular solving as usual, and swap back at the end of
# the routine, so that whatever was passed in symbols is what is returned.
symbols_new = []
symbol_swapped = False
if isinstance(symbols, (list, tuple)):
symbols_passed = symbols[:]
elif isinstance(symbols, set):
symbols_passed = list(symbols)
i = 0
for s in symbols:
if s.is_Symbol:
s_new = s
elif s.is_Function:
symbol_swapped = True
s_new = Symbol('F%d' % i, dummy=True)
elif s.is_Derivative:
symbol_swapped = True
s_new = Symbol('D%d' % i, dummy=True)
else:
raise TypeError('not a Symbol or a Function')
symbols_new.append(s_new)
i += 1
if symbol_swapped:
swap_back_dict = dict(zip(symbols_new, symbols))
# End code for handling of Function and Derivative instances
if not isinstance(f, (tuple, list, set)):
f = sympify(f)
# Create a swap dictionary for storing the passed symbols to be solved
# for, so that they may be swapped back.
if symbol_swapped:
swap_dict = zip(symbols, symbols_new)
f = f.subs(swap_dict)
symbols = symbols_new
if isinstance(f, Equality):
f = f.lhs - f.rhs
if len(symbols) != 1:
raise NotImplementedError('multivariate equation')
symbol = symbols[0]
strategy = guess_solve_strategy(f, symbol)
if strategy == GS_POLY:
poly = f.as_poly( symbol )
assert poly is not None
result = roots(poly, cubics=True, quartics=True).keys()
elif strategy == GS_RATIONAL:
P, Q = f.as_numer_denom()
#TODO: check for Q != 0
return solve(P, symbol, **flags)
elif strategy == GS_POLY_CV_1:
args = list(f.args)
if isinstance(f, Add):
# we must search for a suitable change of variable
# collect exponents
exponents_denom = list()
for arg in args:
if isinstance(arg, Pow):
exponents_denom.append(arg.exp.q)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
exponents_denom.append(mul_arg.exp.q)
assert len(exponents_denom) > 0
if len(exponents_denom) == 1:
m = exponents_denom[0]
else:
# get the GCD of the denominators
m = ilcm(*exponents_denom)
# x -> y**m.
# we assume positive for simplification purposes
t = Symbol('t', positive=True, dummy=True)
f_ = f.subs(symbol, t**m)
if guess_solve_strategy(f_, t) != GS_POLY:
raise TypeError("Could not convert to a polynomial equation: %s" % f_)
cv_sols = solve(f_, t)
for sol in cv_sols:
result.append(sol**m)
elif isinstance(f, Mul):
for mul_arg in args:
result.extend(solve(mul_arg, symbol))
elif strategy == GS_POLY_CV_2:
m = 0
args = list(f.args)
if isinstance(f, Add):
for arg in args:
if isinstance(arg, Pow):
m = min(m, arg.exp)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
elif isinstance(f, Mul):
for mul_arg in args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
f1 = simplify(f*symbol**(-m))
result = solve(f1, symbol)
# TODO: we might have introduced unwanted solutions
# when multiplied by x**-m
elif strategy == GS_TRANSCENDENTAL:
#a, b = f.as_numer_denom()
# Let's throw away the denominator for now. When we have robust
# assumptions, it should be checked, that for the solution,
# b!=0.
result = tsolve(f, *symbols)
elif strategy == -1:
raise ValueError('Could not parse expression %s' % f)
else:
raise NotImplementedError("No algorithms are implemented to solve equation %s" % f)
if flags.get('simplified', True):
return map(simplify, result)
else:
return result
else:
if not f:
return {}
else:
# Create a swap dictionary for storing the passed symbols to be
# solved for, so that they may be swapped back.
if symbol_swapped:
swap_dict = zip(symbols, symbols_new)
f = [fi.subs(swap_dict) for fi in f]
symbols = symbols_new
polys = []
for g in f:
g = sympify(g)
if isinstance(g, Equality):
g = g.lhs - g.rhs
poly = g.as_poly(*symbols)
if poly is not None:
polys.append(poly)
else:
raise NotImplementedError()
if all(p.is_linear for p in polys):
n, m = len(f), len(symbols)
matrix = zeros((n, m + 1))
for i, poly in enumerate(polys):
for coeff, monom in poly.iter_terms():
try:
j = list(monom).index(1)
matrix[i, j] = coeff
except ValueError:
matrix[i, m] = -coeff
soln = solve_linear_system(matrix, *symbols, **flags)
else:
soln = solve_poly_system(polys)
# Use swap_dict to ensure we return the same type as what was
# passed
if symbol_swapped:
if isinstance(soln, dict):
res = {}
for k in soln.keys():
res.update({swap_back_dict[k]: soln[k]})
return res
else:
return soln
else:
return soln
def solve(f, *symbols, **flags):
"""Solves equations and systems of equations.
Currently supported are univariate polynomial and transcendental
equations and systems of linear and polynomial equations. Input
is formed as a single expression or an equation, or an iterable
container in case of an equation system. The type of output may
vary and depends heavily on the input. For more details refer to
more problem specific functions.
By default all solutions are simplified to make the output more
readable. If this is not the expected behavior, eg. because of
speed issues, set simplified=False in function arguments.
To solve equations and systems of equations of other kind, eg.
recurrence relations of differential equations use rsolve() or
dsolve() functions respectively.
>>> from sympy import *
>>> x,y = symbols('xy')
Solve a polynomial equation:
>>> solve(x**4-1, x)
[1, -1, -I, I]
Solve a linear system:
>>> solve((x+5*y-2, -3*x+6*y-15), x, y)
{x: -3, y: 1}
"""
if not symbols:
raise ValueError('no symbols were given')
if len(symbols) == 1:
if isinstance(symbols[0], (list, tuple, set)):
symbols = symbols[0]
symbols = map(sympify, symbols)
if any(not s.is_Symbol for s in symbols):
raise TypeError('not a Symbol')
if not isinstance(f, (tuple, list, set)):
f = sympify(f)
if isinstance(f, Equality):
f = f.lhs - f.rhs
if len(symbols) != 1:
raise NotImplementedError('multivariate equation')
symbol = symbols[0]
strategy = guess_solve_strategy(f, symbol)
if strategy == GS_POLY:
poly = f.as_poly( symbol )
assert poly is not None
result = roots(poly, cubics=True, quartics=True).keys()
elif strategy == GS_RATIONAL:
P, Q = f.as_numer_denom()
#TODO: check for Q != 0
return solve(P, symbol, **flags)
elif strategy == GS_POLY_CV_1:
args = list(f.args)
if isinstance(f, Add):
# we must search for a suitable change of variable
# collect exponents
exponents_denom = list()
for arg in args:
if isinstance(arg, Pow):
exponents_denom.append(arg.exp.q)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
exponents_denom.append(mul_arg.exp.q)
assert len(exponents_denom) > 0
if len(exponents_denom) == 1:
m = exponents_denom[0]
else:
# get the GCD of the denominators
m = ilcm(*exponents_denom)
# x -> y**m.
# we assume positive for simplification purposes
t = Symbol('t', positive=True, dummy=True)
f_ = f.subs(symbol, t**m)
if guess_solve_strategy(f_, t) != GS_POLY:
raise TypeError("Could not convert to a polynomial equation: %s" % f_)
cv_sols = solve(f_, t)
result = list()
for sol in cv_sols:
result.append(sol**m)
elif isinstance(f, Mul):
result = []
for mul_arg in args:
result.extend(solve(mul_arg, symbol))
elif strategy == GS_POLY_CV_2:
m = 0
args = list(f.args)
if isinstance(f, Add):
for arg in args:
if isinstance(arg, Pow):
m = min(m, arg.exp)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
elif isinstance(f, Mul):
for mul_arg in args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
f1 = simplify(f*symbol**(-m))
result = solve(f1, symbol)
# TODO: we might have introduced unwanted solutions
# when multiplied by x**-m
elif strategy == GS_TRASCENDENTAL:
#a, b = f.as_numer_denom()
# Let's throw away the denominator for now. When we have robust
# assumptions, it should be checked, that for the solution,
# b!=0.
result = tsolve(f, *symbols)
elif strategy == -1:
raise Exception('Could not parse expression %s' % f)
else:
raise NotImplementedError("No algorithms where implemented to solve equation %s" % f)
if flags.get('simplified', True):
return map(simplify, result)
else:
return result
else:
if not f:
return {}
else:
polys = []
for g in f:
g = sympify(g)
if isinstance(g, Equality):
g = g.lhs - g.rhs
poly = g.as_poly(*symbols)
if poly is not None:
polys.append(poly)
else:
raise NotImplementedError()
if all(p.is_linear for p in polys):
n, m = len(f), len(symbols)
matrix = zeros((n, m + 1))
for i, poly in enumerate(polys):
for coeff, monom in poly.iter_terms():
try:
j = list(monom).index(1)
matrix[i, j] = coeff
except ValueError:
matrix[i, m] = -coeff
return solve_linear_system(matrix, *symbols, **flags)
else:
return solve_poly_system(polys)
def solve(f, *symbols, **flags):
"""Solves equations and systems of equations.
Currently supported are univariate polynomial, transcendental
equations, piecewise combinations thereof and systems of linear
and polynomial equations. Input is formed as a single expression
or an equation, or an iterable container in case of an equation
system. The type of output may vary and depends heavily on the
input. For more details refer to more problem specific functions.
By default all solutions are simplified to make the output more
readable. If this is not the expected behavior (e.g., because of
speed issues) set simplified=False in function arguments.
To solve equations and systems of equations like recurrence relations
or differential equations, use rsolve() or dsolve(), respectively.
>>> from sympy import I, solve
>>> from sympy.abc import x, y
Solve a polynomial equation:
>>> solve(x**4-1, x)
[1, -1, -I, I]
Solve a linear system:
>>> solve((x+5*y-2, -3*x+6*y-15), x, y)
{x: -3, y: 1}
"""
def sympit(w):
return map(sympify, iff(isinstance(w, (list, tuple, set)), w, [w]))
# make f and symbols into lists of sympified quantities
# keeping track of how f was passed since if it is a list
# a dictionary of results will be returned.
bare_f = not isinstance(f, (list, tuple, set))
f, symbols = (sympit(w) for w in [f, symbols])
for i, fi in enumerate(f):
if isinstance(fi, Equality):
f[i] = fi.lhs - fi.rhs
if not symbols:
#get symbols from equations or supply dummy symbols since
#solve(3,x) returns []...though it seems that it should raise some sort of error TODO
symbols = set([])
for fi in f:
symbols |= fi.atoms(Symbol) or set([Dummy('x')])
symbols = list(symbols)
if bare_f:
f = f[0]
if len(symbols) == 1:
if isinstance(symbols[0], (list, tuple, set)):
symbols = symbols[0]
result = list()
# Begin code handling for Function and Derivative instances
# Basic idea: store all the passed symbols in symbols_passed, check to see
# if any of them are Function or Derivative types, if so, use a dummy
# symbol in their place, and set symbol_swapped = True so that other parts
# of the code can be aware of the swap. Once all swapping is done, the
# continue on with regular solving as usual, and swap back at the end of
# the routine, so that whatever was passed in symbols is what is returned.
symbols_new = []
symbol_swapped = False
symbols_passed = list(symbols)
for i, s in enumerate(symbols):
if s.is_Symbol:
s_new = s
elif s.is_Function:
symbol_swapped = True
s_new = Dummy('F%d' % i)
elif s.is_Derivative:
symbol_swapped = True
s_new = Dummy('D%d' % i)
else:
raise TypeError('not a Symbol or a Function')
symbols_new.append(s_new)
if symbol_swapped:
swap_back_dict = dict(zip(symbols_new, symbols))
# End code for handling of Function and Derivative instances
if not isinstance(f, (tuple, list, set)):
# Create a swap dictionary for storing the passed symbols to be solved
# for, so that they may be swapped back.
if symbol_swapped:
swap_dict = zip(symbols, symbols_new)
f = f.subs(swap_dict)
symbols = symbols_new
# Any embedded piecewise functions need to be brought out to the
# top level so that the appropriate strategy gets selected.
f = piecewise_fold(f)
if len(symbols) != 1:
result = {}
for s in symbols:
result[s] = solve(f, s, **flags)
if flags.get('simplified', True):
for s, r in result.items():
result[s] = map(simplify, r)
return result
symbol = symbols[0]
strategy = guess_solve_strategy(f, symbol)
if strategy == GS_POLY:
poly = f.as_poly(symbol)
if poly is None:
raise NotImplementedError("Cannot solve equation " + str(f) +
" for " + str(symbol))
# for cubics and quartics, if the flag wasn't set, DON'T do it
# by default since the results are quite long. Perhaps one could
# base this decision on a certain crtical length of the roots.
if poly.degree > 2:
flags['simplified'] = flags.get('simplified', False)
result = roots(poly, cubics=True, quartics=True).keys()
elif strategy == GS_RATIONAL:
P, Q = f.as_numer_denom()
#TODO: check for Q != 0
result = solve(P, symbol, **flags)
elif strategy == GS_POLY_CV_1:
args = list(f.args)
if isinstance(f, Add):
# we must search for a suitable change of variable
# collect exponents
exponents_denom = list()
for arg in args:
if isinstance(arg, Pow):
exponents_denom.append(arg.exp.q)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
exponents_denom.append(mul_arg.exp.q)
assert len(exponents_denom) > 0
if len(exponents_denom) == 1:
m = exponents_denom[0]
else:
# get the LCM of the denominators
m = reduce(ilcm, exponents_denom)
# x -> y**m.
# we assume positive for simplification purposes
t = Dummy('t', positive=True)
f_ = f.subs(symbol, t**m)
if guess_solve_strategy(f_, t) != GS_POLY:
raise NotImplementedError(
"Could not convert to a polynomial equation: %s" % f_)
cv_sols = solve(f_, t)
for sol in cv_sols:
result.append(sol**m)
elif isinstance(f, Mul):
for mul_arg in args:
result.extend(solve(mul_arg, symbol))
elif strategy == GS_POLY_CV_2:
m = 0
args = list(f.args)
if isinstance(f, Add):
for arg in args:
if isinstance(arg, Pow):
m = min(m, arg.exp)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
elif isinstance(f, Mul):
for mul_arg in args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
f1 = simplify(f * symbol**(-m))
result = solve(f1, symbol)
# TODO: we might have introduced unwanted solutions
# when multiplied by x**-m
elif strategy == GS_PIECEWISE:
result = set()
for expr, cond in f.args:
candidates = solve(expr, *symbols)
if isinstance(cond, bool) or cond.is_Number:
if not cond:
continue
# Only include solutions that do not match the condition
# of any of the other pieces.
for candidate in candidates:
matches_other_piece = False
for other_expr, other_cond in f.args:
if isinstance(other_cond, bool) \
or other_cond.is_Number:
continue
if bool(other_cond.subs(symbol, candidate)):
matches_other_piece = True
break
if not matches_other_piece:
result.add(candidate)
else:
for candidate in candidates:
if bool(cond.subs(symbol, candidate)):
result.add(candidate)
result = list(result)
elif strategy == GS_TRANSCENDENTAL:
#a, b = f.as_numer_denom()
# Let's throw away the denominator for now. When we have robust
# assumptions, it should be checked, that for the solution,
# b!=0.
result = tsolve(f, *symbols)
elif strategy == -1:
raise ValueError('Could not parse expression %s' % f)
else:
raise NotImplementedError(
"No algorithms are implemented to solve equation %s" % f)
# This symbol swap should not be necessary for the single symbol case: if you've
# solved for the symbol the it will not appear in the solution. Right now, however
# ode's are getting solutions for solve (even though they shouldn't be -- see the
# swap_back test in test_solvers).
if symbol_swapped:
result = [ri.subs(swap_back_dict) for ri in result]
if flags.get('simplified', True) and strategy != GS_RATIONAL:
return map(simplify, result)
else:
return result
else:
if not f:
return {}
else:
# Create a swap dictionary for storing the passed symbols to be
# solved for, so that they may be swapped back.
if symbol_swapped:
swap_dict = zip(symbols, symbols_new)
f = [fi.subs(swap_dict) for fi in f]
symbols = symbols_new
polys = []
for g in f:
poly = g.as_poly(*symbols)
if poly is not None:
polys.append(poly)
else:
raise NotImplementedError()
if all(p.is_linear for p in polys):
n, m = len(f), len(symbols)
matrix = zeros((n, m + 1))
for i, poly in enumerate(polys):
for monom, coeff in poly.terms():
try:
j = list(monom).index(1)
matrix[i, j] = coeff
except ValueError:
matrix[i, m] = -coeff
soln = solve_linear_system(matrix, *symbols, **flags)
else:
soln = solve_poly_system(polys)
# Use swap_dict to ensure we return the same type as what was
# passed
if symbol_swapped:
if isinstance(soln, dict):
res = {}
for k in soln.keys():
res.update({swap_back_dict[k]: soln[k]})
return res
else:
return soln
else:
return soln
def solve(f, *symbols, **flags):
"""Solves equations and systems of equations.
Currently supported are univariate polynomial and transcendental
equations and systems of linear and polynomial equations. Input
is formed as a single expression or an equation, or an iterable
container in case of an equation system. The type of output may
vary and depends heavily on the input. For more details refer to
more problem specific functions.
By default all solutions are simplified to make the output more
readable. If this is not the expected behavior, eg. because of
speed issues, set simplified=False in function arguments.
To solve equations and systems of equations of other kind, eg.
recurrence relations of differential equations use rsolve() or
dsolve() functions respectively.
>>> from sympy import *
>>> x,y = symbols('xy')
Solve a polynomial equation:
>>> solve(x**4-1, x)
[1, -1, -I, I]
Solve a linear system:
>>> solve((x+5*y-2, -3*x+6*y-15), x, y)
{x: -3, y: 1}
"""
if not symbols:
raise ValueError('no symbols were given')
if len(symbols) == 1:
if isinstance(symbols[0], (list, tuple, set)):
symbols = symbols[0]
symbols = map(sympify, symbols)
if any(not s.is_Symbol for s in symbols):
raise TypeError('not a Symbol')
if not isinstance(f, (tuple, list, set)):
f = sympify(f)
if isinstance(f, Equality):
f = f.lhs - f.rhs
if len(symbols) != 1:
raise NotImplementedError('multivariate equation')
symbol = symbols[0]
strategy = guess_solve_strategy(f, symbol)
if strategy == GS_POLY:
poly = f.as_poly(symbol)
assert poly is not None
result = roots(poly, cubics=True, quartics=True).keys()
elif strategy == GS_RATIONAL:
P, Q = f.as_numer_denom()
#TODO: check for Q != 0
return solve(P, symbol, **flags)
elif strategy == GS_POLY_CV_1:
# we must search for a suitable change of variable
# collect exponents
exponents_denom = list()
args = list(f.args)
if isinstance(f, Add):
for arg in args:
if isinstance(arg, Pow):
exponents_denom.append(arg.exp.q)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
exponents_denom.append(mul_arg.exp.q)
elif isinstance(f, Mul):
for mul_arg in args:
if isinstance(mul_arg, Pow):
exponents_denom.append(mul_arg.exp.q)
assert len(exponents_denom) > 0
if len(exponents_denom) == 1:
m = exponents_denom[0]
else:
# get the GCD of the denominators
m = ilcm(*exponents_denom)
# x -> y**m.
# we assume positive for simplification purposes
t = Symbol('t', positive=True, dummy=True)
f_ = f.subs(symbol, t**m)
if guess_solve_strategy(f_, t) != GS_POLY:
raise TypeError(
"Could not convert to a polynomial equation: %s" % f_)
cv_sols = solve(f_, t)
result = list()
for sol in cv_sols:
result.append(sol**(S.One / m))
elif strategy == GS_POLY_CV_2:
m = 0
args = list(f.args)
if isinstance(f, Add):
for arg in args:
if isinstance(arg, Pow):
m = min(m, arg.exp)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
elif isinstance(f, Mul):
for mul_arg in args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
f1 = simplify(f * symbol**(-m))
result = solve(f1, symbol)
# TODO: we might have introduced unwanted solutions
# when multiplied by x**-m
elif strategy == GS_TRASCENDENTAL:
#a, b = f.as_numer_denom()
# Let's throw away the denominator for now. When we have robust
# assumptions, it should be checked, that for the solution,
# b!=0.
result = tsolve(f, *symbols)
elif strategy == -1:
raise Exception('Could not parse expression %s' % f)
else:
raise NotImplementedError(
"No algorithms where implemented to solve equation %s" % f)
if flags.get('simplified', True):
return map(simplify, result)
else:
return result
else:
if not f:
return {}
else:
polys = []
for g in f:
g = sympify(g)
if isinstance(g, Equality):
g = g.lhs - g.rhs
poly = g.as_poly(*symbols)
if poly is not None:
polys.append(poly)
else:
raise NotImplementedError
if all(p.is_linear for p in polys):
n, m = len(f), len(symbols)
matrix = zeros((n, m + 1))
for i, poly in enumerate(polys):
for coeff, monom in poly.iter_terms():
try:
j = list(monom).index(1)
matrix[i, j] = coeff
except ValueError:
matrix[i, m] = -coeff
return solve_linear_system(matrix, *symbols, **flags)
else:
return solve_poly_system(polys)
def _solve(f, *symbols, **flags):
""" Return a checked solution for f in terms of one or more of the symbols."""
if not iterable(f):
if len(symbols) != 1:
soln = None
free = f.free_symbols
ex = free - set(symbols)
if len(ex) == 1:
ex = ex.pop()
try:
# may come back as dict or list (if non-linear)
soln = solve_undetermined_coeffs(f, symbols, ex)
except NotImplementedError:
pass
if not soln is None:
return soln
# find first successful solution
failed = []
for s in symbols:
n, d = solve_linear(f, x=[s])
if n.is_Symbol:
soln = {n: cancel(d)}
return soln
failed.append(s)
for s in failed:
try:
soln = _solve(f, s, **flags)
return soln
except NotImplementedError:
pass
else:
msg = "No algorithms are implemented to solve equation %s"
raise NotImplementedError(msg % f)
symbol = symbols[0]
# first see if it really depends on symbol and whether there
# is a linear solution
f_num, sol = solve_linear(f, x=symbols)
if not symbol in f_num.free_symbols:
return []
elif f_num.is_Symbol:
return [cancel(sol)]
strategy = guess_solve_strategy(f, symbol)
result = False # no solution was obtained
if strategy == GS_POLY:
poly = f.as_poly(symbol)
if poly is None:
msg = "Cannot solve equation %s for %s" % (f, symbol)
else:
# for cubics and quartics, if the flag wasn't set, DON'T do it
# by default since the results are quite long. Perhaps one could
# base this decision on a certain critical length of the roots.
if poly.degree() > 2:
flags['simplified'] = flags.get('simplified', False)
result = roots(poly, cubics=True, quartics=True).keys()
elif strategy == GS_RATIONAL:
P, _ = f.as_numer_denom()
dens = denoms(f, x=symbols)
try:
soln = _solve(P, symbol, **flags)
except NotImplementedError:
msg = "Cannot solve equation %s for %s" % (P, symbol)
result = []
else:
if dens:
# reject any result that makes any denom. affirmatively 0;
# if in doubt, keep it
result = [
s for s in soln
if all(not checksol(den, {symbol: s}) for den in dens)
]
else:
result = soln
elif strategy == GS_POLY_CV_1:
args = list(f.args)
if isinstance(f, Pow):
result = _solve(args[0], symbol, **flags)
elif isinstance(f, Add):
# we must search for a suitable change of variables
# collect exponents
exponents_denom = list()
for arg in args:
if isinstance(arg, Pow):
exponents_denom.append(arg.exp.q)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
exponents_denom.append(mul_arg.exp.q)
assert len(exponents_denom) > 0
if len(exponents_denom) == 1:
m = exponents_denom[0]
else:
# get the LCM of the denominators
m = reduce(ilcm, exponents_denom)
# x -> y**m.
# we assume positive for simplification purposes
t = Dummy('t', positive=True)
f_ = f.subs(symbol, t**m)
if guess_solve_strategy(f_, t) != GS_POLY:
msg = "Could not convert to a polynomial equation: %s" % f_
result = []
else:
soln = [s**m for s in _solve(f_, t)]
# we might have introduced solutions from another branch
# when changing variables; check and keep solutions
# unless they definitely aren't a solution
result = [
s for s in soln
if checksol(f, {symbol: s}) is not False
]
elif isinstance(f, Mul):
result = []
for m in f.args:
result.extend(_solve(m, symbol, **flags) or [])
elif strategy == GS_POLY_CV_2:
m = 0
args = list(f.args)
if isinstance(f, Add):
for arg in args:
if isinstance(arg, Pow):
m = min(m, arg.exp)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
elif isinstance(f, Mul):
for mul_arg in args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
if m and m != 1:
f_ = simplify(f * symbol**(-m))
try:
sols = _solve(f_, symbol)
except NotImplementedError:
msg = 'Could not solve %s for %s' % (f_, symbol)
else:
# we might have introduced unwanted solutions
# when multiplying by x**-m; check and keep solutions
# unless they definitely aren't a solution
if sols:
result = [
s for s in sols
if checksol(f, {symbol: s}) is not False
]
else:
msg = 'CV_2 calculated %d but it should have been other than 0 or 1' % m
elif strategy == GS_PIECEWISE:
result = set()
for expr, cond in f.args:
candidates = _solve(expr, *symbols)
if isinstance(cond, bool) or cond.is_Number:
if not cond:
continue
# Only include solutions that do not match the condition
# of any of the other pieces.
for candidate in candidates:
matches_other_piece = False
for other_expr, other_cond in f.args:
if isinstance(other_cond, bool) \
or other_cond.is_Number:
continue
if bool(other_cond.subs(symbol, candidate)):
matches_other_piece = True
break
if not matches_other_piece:
result.add(candidate)
else:
for candidate in candidates:
if bool(cond.subs(symbol, candidate)):
result.add(candidate)
result = list(result)
elif strategy == -1:
raise ValueError('Could not parse expression %s' % f)
# this is the fallback for not getting any other solution
if result is False or strategy == GS_TRANSCENDENTAL:
soln = tsolve(f_num, symbol)
dens = denoms(f, x=symbols)
if not dens:
result = soln
else:
# reject any result that makes any denom. affirmatively 0;
# if in doubt, keep it
result = [
s for s in soln
if all(not checksol(den, {symbol: s}) for den in dens)
]
if result is False:
raise NotImplementedError(
msg +
"\nNo algorithms are implemented to solve equation %s" % f)
if flags.get('simplified', True) and strategy != GS_RATIONAL:
result = map(simplify, result)
return result
else:
if not f:
return []
else:
polys = []
for g in f:
poly = g.as_poly(*symbols, **{'extension': True})
if poly is not None:
polys.append(poly)
else:
raise NotImplementedError()
if all(p.is_linear for p in polys):
n, m = len(f), len(symbols)
matrix = zeros((n, m + 1))
for i, poly in enumerate(polys):
for monom, coeff in poly.terms():
try:
j = list(monom).index(1)
matrix[i, j] = coeff
except ValueError:
matrix[i, m] = -coeff
# a dictionary of symbols: values or None
result = solve_linear_system(matrix, *symbols, **flags)
return result
else:
# a list of tuples, T, where T[i] [j] corresponds to the ith solution for symbols[j]
result = solve_poly_system(polys)
return result
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))
def _solve(f, *symbols, **flags):
""" Return a checked solution for f in terms of one or more of the symbols."""
check = flags.get('check', True)
if not iterable(f):
if len(symbols) != 1:
soln = None
free = f.free_symbols
ex = free - set(symbols)
if len(ex) == 1:
ex = ex.pop()
try:
# may come back as dict or list (if non-linear)
soln = solve_undetermined_coeffs(f, symbols, ex)
except NotImplementedError:
pass
if not soln is None:
return soln
# find first successful solution
failed = []
for s in symbols:
n, d = solve_linear(f, symbols=[s])
if n.is_Symbol:
return [{n: cancel(d)}]
failed.append(s)
for s in failed:
try:
soln = _solve(f, s, **flags)
except NotImplementedError:
continue
if soln:
return [{s: sol} for sol in soln]
else:
return soln
else:
msg = "No algorithms are implemented to solve equation %s"
raise NotImplementedError(msg % f)
symbol = symbols[0]
# build up solutions if f is a Mul
if f.is_Mul:
result = set()
dens = denoms(f, symbols)
for m in f.args:
soln = _solve(m, symbol, **flags)
result.update(set(soln))
if check:
result = [s for s in result if all(not checksol(den, {symbol: s}, **flags) for den in dens)]
elif f.is_Piecewise:
result = set()
for expr, cond in f.args:
candidates = _solve(expr, *symbols)
if isinstance(cond, bool) or cond.is_Number:
if not cond:
continue
# Only include solutions that do not match the condition
# of any of the other pieces.
for candidate in candidates:
matches_other_piece = False
for other_expr, other_cond in f.args:
if isinstance(other_cond, bool) \
or other_cond.is_Number:
continue
if bool(other_cond.subs(symbol, candidate)):
matches_other_piece = True
break
if not matches_other_piece:
result.add(candidate)
else:
for candidate in candidates:
if bool(cond.subs(symbol, candidate)):
result.add(candidate)
dens = set() # all checking has already been done
else:
# first see if it really depends on symbol and whether there
# is a linear solution
f_num, sol = solve_linear(f, symbols=symbols)
if not symbol in f_num.free_symbols:
return []
elif f_num.is_Symbol:
return [cancel(sol)]
result = False # no solution was obtained
msg = '' # there is no failure message
dens = denoms(f, symbols) # store these for checking later
# 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.
poly = Poly(f_num)
if poly is None:
raise ValueError('could not convert %s to Poly' % f_num)
gens = [g for g in poly.gens if g.has(symbol)]
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')
# >>> Poly(sqrt(x)+sqrt(sqrt(x)))
# Poly(sqrt(x) + x**(1/4), sqrt(x), x**(1/4), domain='ZZ')
# If the exponents are Rational then a change of variables
# will make this a polynomial equation in a single base.
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 not c is S.One: # c could be a Float
return b**ee, c.q
return x, 1
bases, qs = zip(*[as_base_q(g) for g in gens])
bases = set(bases)
if len(bases) == 1 and any(q != 1 for q in qs):
# e.g. for x**(1/2) + x**(1/4) a change of variables
# can be made using p**4 to give p**2 + p
base = bases.pop()
m = reduce(ilcm, qs)
p = Dummy('p', positive=True)
cov = p**m
fnew = f_num.subs(base, cov)
poly = Poly(fnew, p) # we now have a single generator, p
# for cubics and quartics, if the flag wasn't set, DON'T do it
# by default since the results are quite long. Perhaps one could
# base this decision on a certain critical length of the roots.
if poly.degree() > 2:
flags['simplify'] = flags.get('simplify', False)
soln = roots(poly, cubics=True, quartics=True).keys()
# We now know what the values of p are equal to. Now find out
# how they are related to the original x, e.g. if p**2 = cos(x) then
# x = acos(p**2)
#
inversion = _solve(cov - base, symbol, **flags)
result = [i.subs(p, s) for i in inversion for s in soln]
if check:
result = [r for r in result if checksol(f_num, {symbol: r}, **flags) is not False]
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.
if len(poly.gens) > 1:
poly = Poly(poly, gens[0])
# if we haven't tried tsolve yet, do so now
if not flags.pop('tsolve', False):
# for cubics and quartics, if the flag wasn't set, DON'T do it
# by default since the results are quite long. Perhaps one could
# base this decision on a certain critical length of the roots.
if poly.degree() > 2:
flags['simplify'] = flags.get('simplify', False)
soln = roots(poly, cubics=True, quartics=True).keys()
gen = poly.gen
if gen != symbol:
u = Dummy()
flags['tsolve'] = True
inversion = _solve(gen - u, symbol, **flags)
soln = list(set([i.subs(u, s) for i in inversion for s in soln]))
result = soln
else:
msg = 'multiple generators %s' % gens
# fallback if above fails
if result is False:
result = _tsolve(f_num, symbol, **flags) or False
if result is False:
raise NotImplementedError(msg +
"\nNo algorithms are implemented to solve equation %s" % f)
if flags.get('simplify', True):
result = map(simplify, result)
# reject any result that makes any denom. affirmatively 0;
# if in doubt, keep it
if check:
result = [s for s in result if
all(not checksol(den, {symbol: s}, **flags)
for den in dens)]
return result
else:
if not f:
return []
else:
polys = []
for g in f:
poly = g.as_poly(*symbols, **{'extension': True})
if poly is not None:
polys.append(poly)
else:
raise NotImplementedError()
if all(p.is_linear for p in polys):
n, m = len(f), len(symbols)
matrix = zeros(n, m + 1)
for i, poly in enumerate(polys):
for monom, coeff in poly.terms():
try:
j = list(monom).index(1)
matrix[i, j] = coeff
except ValueError:
matrix[i, m] = -coeff
# a dictionary of symbols: values or None
result = solve_linear_system(matrix, *symbols, **flags)
return result
else:
# a list of tuples, T, where T[i] [j] corresponds to the ith solution for symbols[j]
result = solve_poly_system(polys)
return result
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, 3*y/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), -S.Half), (I*sqrt(S.Half), -S.Half)]
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))
def solve(f, *symbols, **flags):
"""Solves equations and systems of equations.
Currently supported are univariate polynomial and transcendental
equations and systems of linear and polynomial equations. Input
is formed as a single expression or an equation, or an iterable
container in case of an equation system. The type of output may
vary and depends heavily on the input. For more details refer to
more problem specific functions.
By default all solutions are simplified to make the output more
readable. If this is not the expected behavior, eg. because of
speed issues, set simplified=False in function arguments.
To solve equations and systems of equations of other kind, eg.
recurrence relations of differential equations use rsolve() or
dsolve() functions respectively.
>>> from sympy import *
>>> x,y = symbols('xy')
Solve a polynomial equation:
>>> solve(x**4-1, x)
[1, -1, -I, I]
Solve a linear system:
>>> solve((x+5*y-2, -3*x+6*y-15), x, y)
{x: -3, y: 1}
"""
if not symbols:
raise ValueError('no symbols were given')
if len(symbols) == 1:
if isinstance(symbols[0], (list, tuple, set)):
symbols = symbols[0]
symbols = map(sympify, symbols)
result = list()
# Begin code handling for Function and Derivative instances
# Basic idea: store all the passed symbols in symbols_passed, check to see
# if any of them are Function or Derivative types, if so, use a dummy
# symbol in their place, and set symbol_swapped = True so that other parts
# of the code can be aware of the swap. Once all swapping is done, the
# continue on with regular solving as usual, and swap back at the end of
# the routine, so that whatever was passed in symbols is what is returned.
symbols_new = []
symbol_swapped = False
if isinstance(symbols, (list, tuple)):
symbols_passed = symbols[:]
elif isinstance(symbols, set):
symbols_passed = list(symbols)
i = 0
for s in symbols:
if s.is_Symbol:
s_new = s
elif s.is_Function:
symbol_swapped = True
s_new = Symbol('F%d' % i, dummy=True)
elif s.is_Derivative:
symbol_swapped = True
s_new = Symbol('D%d' % i, dummy=True)
else:
raise TypeError('not a Symbol or a Function')
symbols_new.append(s_new)
i += 1
if symbol_swapped:
swap_back_dict = dict(zip(symbols_new, symbols))
# End code for handling of Function and Derivative instances
if not isinstance(f, (tuple, list, set)):
f = sympify(f)
# Create a swap dictionary for storing the passed symbols to be solved
# for, so that they may be swapped back.
if symbol_swapped:
swap_dict = zip(symbols, symbols_new)
f = f.subs(swap_dict)
symbols = symbols_new
if isinstance(f, Equality):
f = f.lhs - f.rhs
if len(symbols) != 1:
raise NotImplementedError('multivariate equation')
symbol = symbols[0]
strategy = guess_solve_strategy(f, symbol)
if strategy == GS_POLY:
poly = f.as_poly(symbol)
assert poly is not None
result = roots(poly, cubics=True, quartics=True).keys()
elif strategy == GS_RATIONAL:
P, Q = f.as_numer_denom()
#TODO: check for Q != 0
return solve(P, symbol, **flags)
elif strategy == GS_POLY_CV_1:
args = list(f.args)
if isinstance(f, Add):
# we must search for a suitable change of variable
# collect exponents
exponents_denom = list()
for arg in args:
if isinstance(arg, Pow):
exponents_denom.append(arg.exp.q)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
exponents_denom.append(mul_arg.exp.q)
assert len(exponents_denom) > 0
if len(exponents_denom) == 1:
m = exponents_denom[0]
else:
# get the GCD of the denominators
m = ilcm(*exponents_denom)
# x -> y**m.
# we assume positive for simplification purposes
t = Symbol('t', positive=True, dummy=True)
f_ = f.subs(symbol, t**m)
if guess_solve_strategy(f_, t) != GS_POLY:
raise TypeError(
"Could not convert to a polynomial equation: %s" % f_)
cv_sols = solve(f_, t)
for sol in cv_sols:
result.append(sol**m)
elif isinstance(f, Mul):
for mul_arg in args:
result.extend(solve(mul_arg, symbol))
elif strategy == GS_POLY_CV_2:
m = 0
args = list(f.args)
if isinstance(f, Add):
for arg in args:
if isinstance(arg, Pow):
m = min(m, arg.exp)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
elif isinstance(f, Mul):
for mul_arg in args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
f1 = simplify(f * symbol**(-m))
result = solve(f1, symbol)
# TODO: we might have introduced unwanted solutions
# when multiplied by x**-m
elif strategy == GS_TRANSCENDENTAL:
#a, b = f.as_numer_denom()
# Let's throw away the denominator for now. When we have robust
# assumptions, it should be checked, that for the solution,
# b!=0.
result = tsolve(f, *symbols)
elif strategy == -1:
raise ValueError('Could not parse expression %s' % f)
else:
raise NotImplementedError(
"No algorithms are implemented to solve equation %s" % f)
if flags.get('simplified', True):
return map(simplify, result)
else:
return result
else:
if not f:
return {}
else:
# Create a swap dictionary for storing the passed symbols to be
# solved for, so that they may be swapped back.
if symbol_swapped:
swap_dict = zip(symbols, symbols_new)
f = [fi.subs(swap_dict) for fi in f]
symbols = symbols_new
polys = []
for g in f:
g = sympify(g)
if isinstance(g, Equality):
g = g.lhs - g.rhs
poly = g.as_poly(*symbols)
if poly is not None:
polys.append(poly)
else:
raise NotImplementedError()
if all(p.is_linear for p in polys):
n, m = len(f), len(symbols)
matrix = zeros((n, m + 1))
for i, poly in enumerate(polys):
for coeff, monom in poly.iter_terms():
try:
j = list(monom).index(1)
matrix[i, j] = coeff
except ValueError:
matrix[i, m] = -coeff
soln = solve_linear_system(matrix, *symbols, **flags)
else:
soln = solve_poly_system(polys)
# Use swap_dict to ensure we return the same type as what was
# passed
if symbol_swapped:
if isinstance(soln, dict):
res = {}
for k in soln.keys():
res.update({swap_back_dict[k]: soln[k]})
return res
else:
return soln
else:
return soln
def _solve(f, *symbols, **flags):
"""Solves equations and systems of equations.
Currently supported are univariate polynomial, transcendental
equations, piecewise combinations thereof and systems of linear
and polynomial equations. Input is formed as a single expression
or an equation, or an iterable container in case of an equation
system. The type of output may vary and depends heavily on the
input. For more details refer to more problem specific functions.
By default all solutions are simplified to make the output more
readable. If this is not the expected behavior (e.g., because of
speed issues) set simplified=False in function arguments.
To solve equations and systems of equations like recurrence relations
or differential equations, use rsolve() or dsolve(), respectively.
>>> from sympy import I, solve
>>> from sympy.abc import x, y
Solve a polynomial equation:
>>> solve(x**4-1, x)
[1, -1, -I, I]
Solve a linear system:
>>> solve((x+5*y-2, -3*x+6*y-15), x, y)
{x: -3, y: 1}
"""
def sympified_list(w):
return map(sympify, iff(isinstance(w, (list, tuple, set)), w, [w]))
# make f and symbols into lists of sympified quantities
# keeping track of how f was passed since if it is a list
# a dictionary of results will be returned.
bare_f = not iterable(f)
f, symbols = (sympified_list(w) for w in [f, symbols])
for i, fi in enumerate(f):
if isinstance(fi, Equality):
f[i] = fi.lhs - fi.rhs
elif isinstance(fi, Poly):
f[i] = fi.as_expr()
elif isinstance(fi, bool) or fi.is_Relational:
return reduce_inequalities(f, assume=flags.get('assume'))
if not symbols:
#get symbols from equations or supply dummy symbols since
#solve(3,x) returns []...though it seems that it should raise some sort of error TODO
symbols = set([])
for fi in f:
symbols |= fi.free_symbols or set([Dummy('x')])
symbols = list(symbols)
symbols.sort(key=Basic.sort_key)
if len(symbols) == 1:
if isinstance(symbols[0], (list, tuple, set)):
symbols = symbols[0]
result = list()
# Begin code handling for Function and Derivative instances
# Basic idea: store all the passed symbols in symbols_passed, check to see
# if any of them are Function or Derivative types, if so, use a dummy
# symbol in their place, and set symbol_swapped = True so that other parts
# of the code can be aware of the swap. Once all swapping is done, the
# continue on with regular solving as usual, and swap back at the end of
# the routine, so that whatever was passed in symbols is what is returned.
symbols_new = []
symbol_swapped = False
symbols_passed = list(symbols)
for i, s in enumerate(symbols):
if s.is_Symbol:
s_new = s
elif s.is_Function:
symbol_swapped = True
s_new = Dummy('F%d' % i)
elif s.is_Derivative:
symbol_swapped = True
s_new = Dummy('D%d' % i)
else:
raise TypeError('not a Symbol or a Function')
symbols_new.append(s_new)
if symbol_swapped:
swap_back_dict = dict(zip(symbols_new, symbols))
# End code for handling of Function and Derivative instances
if bare_f:
f = f[0]
# Create a swap dictionary for storing the passed symbols to be solved
# for, so that they may be swapped back.
if symbol_swapped:
swap_dict = zip(symbols, symbols_new)
f = f.subs(swap_dict)
symbols = symbols_new
# Any embedded piecewise functions need to be brought out to the
# top level so that the appropriate strategy gets selected.
f = piecewise_fold(f)
if len(symbols) != 1:
soln = None
free = f.free_symbols
ex = free - set(symbols)
if len(ex) == 1:
ex = ex.pop()
try:
# may come back as dict or list (if non-linear)
soln = solve_undetermined_coeffs(f, symbols, ex)
except NotImplementedError:
pass
if soln is None:
n, d = solve_linear(f, x=symbols)
if n.is_Symbol:
soln = {n: cancel(d)}
if soln:
if symbol_swapped and isinstance(soln, dict):
return dict([(swap_back_dict[k], v.subs(swap_back_dict))
for k, v in soln.iteritems()])
return soln
symbol = symbols[0]
# first see if it really depends on symbol and whether there
# is a linear solution
f_num, sol = solve_linear(f, x=symbols)
if not symbol in f_num.free_symbols:
return []
elif f_num.is_Symbol:
return [cancel(sol)]
strategy = guess_solve_strategy(f, symbol)
result = False # no solution was obtained
if strategy == GS_POLY:
poly = f.as_poly(symbol)
if poly is None:
msg = "Cannot solve equation %s for %s" % (f, symbol)
else:
# for cubics and quartics, if the flag wasn't set, DON'T do it
# by default since the results are quite long. Perhaps one could
# base this decision on a certain crtical length of the roots.
if poly.degree() > 2:
flags['simplified'] = flags.get('simplified', False)
result = roots(poly, cubics=True, quartics=True).keys()
elif strategy == GS_RATIONAL:
P, _ = f.as_numer_denom()
dens = denoms(f, x=symbols)
# reject any result that makes Q affirmatively 0;
# if in doubt, keep it
try:
soln = _solve(P, symbol, **flags)
except NotImplementedError:
msg = "Cannot solve equation %s for %s" % (P, symbol)
result = []
else:
if dens:
result = [
s for s in soln
if all(not checksol(den, {symbol: s}) for den in dens)
]
else:
result = soln
elif strategy == GS_POLY_CV_1:
args = list(f.args)
if isinstance(f, Pow):
result = _solve(args[0], symbol, **flags)
elif isinstance(f, Add):
# we must search for a suitable change of variables
# collect exponents
exponents_denom = list()
for arg in args:
if isinstance(arg, Pow):
exponents_denom.append(arg.exp.q)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
exponents_denom.append(mul_arg.exp.q)
assert len(exponents_denom) > 0
if len(exponents_denom) == 1:
m = exponents_denom[0]
else:
# get the LCM of the denominators
m = reduce(ilcm, exponents_denom)
# x -> y**m.
# we assume positive for simplification purposes
t = Dummy('t', positive=True)
f_ = f.subs(symbol, t**m)
if guess_solve_strategy(f_, t) != GS_POLY:
msg = "Could not convert to a polynomial equation: %s" % f_
result = []
else:
soln = [s**m for s in _solve(f_, t)]
# we might have introduced solutions from another branch
# when changing variables; check and keep solutions
# unless they definitely aren't a solution
result = [
s for s in soln
if checksol(f, {symbol: s}) is not False
]
elif isinstance(f, Mul):
result = []
for m in f.args:
result.extend(_solve(m, symbol, **flags) or [])
elif strategy == GS_POLY_CV_2:
m = 0
args = list(f.args)
if isinstance(f, Add):
for arg in args:
if isinstance(arg, Pow):
m = min(m, arg.exp)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
elif isinstance(f, Mul):
for mul_arg in args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
if m and m != 1:
f_ = simplify(f * symbol**(-m))
try:
sols = _solve(f_, symbol)
except NotImplementedError:
msg = 'Could not solve %s for %s' % (f_, symbol)
else:
# we might have introduced unwanted solutions
# when multiplying by x**-m; check and keep solutions
# unless they definitely aren't a solution
if sols:
result = [
s for s in sols
if checksol(f, {symbol: s}) is not False
]
else:
msg = 'CV_2 calculated %d but it should have been other than 0 or 1' % m
elif strategy == GS_PIECEWISE:
result = set()
for expr, cond in f.args:
candidates = _solve(expr, *symbols)
if isinstance(cond, bool) or cond.is_Number:
if not cond:
continue
# Only include solutions that do not match the condition
# of any of the other pieces.
for candidate in candidates:
matches_other_piece = False
for other_expr, other_cond in f.args:
if isinstance(other_cond, bool) \
or other_cond.is_Number:
continue
if bool(other_cond.subs(symbol, candidate)):
matches_other_piece = True
break
if not matches_other_piece:
result.add(candidate)
else:
for candidate in candidates:
if bool(cond.subs(symbol, candidate)):
result.add(candidate)
result = list(result)
elif strategy == -1:
raise ValueError('Could not parse expression %s' % f)
# this is the fallback for not getting any other solution
if result is False or strategy == GS_TRANSCENDENTAL:
# reject any result that makes any dens affirmatively 0,
# if in doubt, keep it
soln = tsolve(f_num, symbol)
dens = denoms(f, x=symbols)
if not dens:
result = soln
else:
result = [
s for s in soln
if all(not checksol(den, {symbol: s}) for den in dens)
]
if result is False:
raise NotImplementedError(
msg +
"\nNo algorithms are implemented to solve equation %s" % f)
if flags.get('simplified', True) and strategy != GS_RATIONAL:
result = map(simplify, result)
return result
else:
if not f:
return []
else:
# Create a swap dictionary for storing the passed symbols to be
# solved for, so that they may be swapped back.
if symbol_swapped:
swap_dict = zip(symbols, symbols_new)
f = [fi.subs(swap_dict) for fi in f]
symbols = symbols_new
polys = []
for g in f:
poly = g.as_poly(*symbols, extension=True)
if poly is not None:
polys.append(poly)
else:
raise NotImplementedError()
if all(p.is_linear for p in polys):
n, m = len(f), len(symbols)
matrix = zeros((n, m + 1))
for i, poly in enumerate(polys):
for monom, coeff in poly.terms():
try:
j = list(monom).index(1)
matrix[i, j] = coeff
except ValueError:
matrix[i, m] = -coeff
# a dictionary of symbols: values or None
soln = solve_linear_system(matrix, *symbols, **flags)
# Use swap_dict to ensure we return the same type as what was
# passed; this is not necessary in the poly-system case which
# only supports zero-dimensional systems
if symbol_swapped and soln:
soln = dict([(swap_back_dict[k], v.subs(swap_back_dict))
for k, v in soln.iteritems()])
return soln
else:
# a list of tuples, T, where T[i] [j] corresponds to the ith solution for symbols[j]
return solve_poly_system(polys)
def _solve(f, *symbols, **flags):
"""Solves equations and systems of equations.
Currently supported are univariate polynomial, transcendental
equations, piecewise combinations thereof and systems of linear
and polynomial equations. Input is formed as a single expression
or an equation, or an iterable container in case of an equation
system. The type of output may vary and depends heavily on the
input. For more details refer to more problem specific functions.
By default all solutions are simplified to make the output more
readable. If this is not the expected behavior (e.g., because of
speed issues) set simplified=False in function arguments.
To solve equations and systems of equations like recurrence relations
or differential equations, use rsolve() or dsolve(), respectively.
>>> from sympy import I, solve
>>> from sympy.abc import x, y
Solve a polynomial equation:
>>> solve(x**4-1, x)
[1, -1, -I, I]
Solve a linear system:
>>> solve((x+5*y-2, -3*x+6*y-15), x, y)
{x: -3, y: 1}
"""
def sympified_list(w):
return map(sympify, iff(isinstance(w,(list, tuple, set)), w, [w]))
# make f and symbols into lists of sympified quantities
# keeping track of how f was passed since if it is a list
# a dictionary of results will be returned.
bare_f = not iterable(f)
f, symbols = (sympified_list(w) for w in [f, symbols])
for i, fi in enumerate(f):
if isinstance(fi, Equality):
f[i] = fi.lhs - fi.rhs
elif isinstance(fi, Poly):
f[i] = fi.as_expr()
elif isinstance(fi, bool) or fi.is_Relational:
return reduce_inequalities(f, assume=flags.get('assume'))
if not symbols:
#get symbols from equations or supply dummy symbols since
#solve(3,x) returns []...though it seems that it should raise some sort of error TODO
symbols = set([])
for fi in f:
symbols |= fi.free_symbols or set([Dummy('x')])
symbols = list(symbols)
symbols.sort(key=Basic.sort_key)
if len(symbols) == 1:
if isinstance(symbols[0], (list, tuple, set)):
symbols = symbols[0]
result = list()
# Begin code handling for Function and Derivative instances
# Basic idea: store all the passed symbols in symbols_passed, check to see
# if any of them are Function or Derivative types, if so, use a dummy
# symbol in their place, and set symbol_swapped = True so that other parts
# of the code can be aware of the swap. Once all swapping is done, the
# continue on with regular solving as usual, and swap back at the end of
# the routine, so that whatever was passed in symbols is what is returned.
symbols_new = []
symbol_swapped = False
symbols_passed = list(symbols)
for i, s in enumerate(symbols):
if s.is_Symbol:
s_new = s
elif s.is_Function:
symbol_swapped = True
s_new = Dummy('F%d' % i)
elif s.is_Derivative:
symbol_swapped = True
s_new = Dummy('D%d' % i)
else:
raise TypeError('not a Symbol or a Function')
symbols_new.append(s_new)
if symbol_swapped:
swap_back_dict = dict(zip(symbols_new, symbols))
# End code for handling of Function and Derivative instances
if bare_f:
f = f[0]
# Create a swap dictionary for storing the passed symbols to be solved
# for, so that they may be swapped back.
if symbol_swapped:
swap_dict = zip(symbols, symbols_new)
f = f.subs(swap_dict)
symbols = symbols_new
# Any embedded piecewise functions need to be brought out to the
# top level so that the appropriate strategy gets selected.
f = piecewise_fold(f)
if len(symbols) != 1:
soln = None
free = f.free_symbols
ex = free - set(symbols)
if len(ex) == 1:
ex = ex.pop()
try:
# may come back as dict or list (if non-linear)
soln = solve_undetermined_coeffs(f, symbols, ex)
except NotImplementedError:
pass
if soln is None:
n, d = solve_linear(f, x=symbols)
if n.is_Symbol:
soln = {n: cancel(d)}
if soln:
if symbol_swapped and isinstance(soln, dict):
return dict([(swap_back_dict[k],
v.subs(swap_back_dict))
for k, v in soln.iteritems()])
return soln
symbol = symbols[0]
# first see if it really depends on symbol and whether there
# is a linear solution
f_num, sol = solve_linear(f, x=symbols)
if not symbol in f_num.free_symbols:
return []
elif f_num.is_Symbol:
return [cancel(sol)]
strategy = guess_solve_strategy(f, symbol)
result = False # no solution was obtained
if strategy == GS_POLY:
poly = f.as_poly(symbol)
if poly is None:
msg = "Cannot solve equation %s for %s" % (f, symbol)
else:
# for cubics and quartics, if the flag wasn't set, DON'T do it
# by default since the results are quite long. Perhaps one could
# base this decision on a certain crtical length of the roots.
if poly.degree() > 2:
flags['simplified'] = flags.get('simplified', False)
result = roots(poly, cubics=True, quartics=True).keys()
elif strategy == GS_RATIONAL:
P, _ = f.as_numer_denom()
dens = denoms(f, x=symbols)
# reject any result that makes Q affirmatively 0;
# if in doubt, keep it
try:
soln = _solve(P, symbol, **flags)
except NotImplementedError:
msg = "Cannot solve equation %s for %s" % (P, symbol)
result = []
else:
if dens:
result = [s for s in soln if all(not checksol(den, {symbol: s}) for den in dens)]
else:
result = soln
elif strategy == GS_POLY_CV_1:
args = list(f.args)
if isinstance(f, Pow):
result = _solve(args[0], symbol, **flags)
elif isinstance(f, Add):
# we must search for a suitable change of variables
# collect exponents
exponents_denom = list()
for arg in args:
if isinstance(arg, Pow):
exponents_denom.append(arg.exp.q)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
exponents_denom.append(mul_arg.exp.q)
assert len(exponents_denom) > 0
if len(exponents_denom) == 1:
m = exponents_denom[0]
else:
# get the LCM of the denominators
m = reduce(ilcm, exponents_denom)
# x -> y**m.
# we assume positive for simplification purposes
t = Dummy('t', positive=True)
f_ = f.subs(symbol, t**m)
if guess_solve_strategy(f_, t) != GS_POLY:
msg = "Could not convert to a polynomial equation: %s" % f_
result = []
else:
soln = [s**m for s in _solve(f_, t)]
# we might have introduced solutions from another branch
# when changing variables; check and keep solutions
# unless they definitely aren't a solution
result = [s for s in soln if checksol(f, {symbol: s}) is not False]
elif isinstance(f, Mul):
result = []
for m in f.args:
result.extend(_solve(m, symbol, **flags) or [])
elif strategy == GS_POLY_CV_2:
m = 0
args = list(f.args)
if isinstance(f, Add):
for arg in args:
if isinstance(arg, Pow):
m = min(m, arg.exp)
elif isinstance(arg, Mul):
for mul_arg in arg.args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
elif isinstance(f, Mul):
for mul_arg in args:
if isinstance(mul_arg, Pow):
m = min(m, mul_arg.exp)
if m and m != 1:
f_ = simplify(f*symbol**(-m))
try:
sols = _solve(f_, symbol)
except NotImplementedError:
msg = 'Could not solve %s for %s' % (f_, symbol)
else:
# we might have introduced unwanted solutions
# when multiplying by x**-m; check and keep solutions
# unless they definitely aren't a solution
if sols:
result = [s for s in sols if checksol(f, {symbol: s}) is not False]
else:
msg = 'CV_2 calculated %d but it should have been other than 0 or 1' % m
elif strategy == GS_PIECEWISE:
result = set()
for expr, cond in f.args:
candidates = _solve(expr, *symbols)
if isinstance(cond, bool) or cond.is_Number:
if not cond:
continue
# Only include solutions that do not match the condition
# of any of the other pieces.
for candidate in candidates:
matches_other_piece = False
for other_expr, other_cond in f.args:
if isinstance(other_cond, bool) \
or other_cond.is_Number:
continue
if bool(other_cond.subs(symbol, candidate)):
matches_other_piece = True
break
if not matches_other_piece:
result.add(candidate)
else:
for candidate in candidates:
if bool(cond.subs(symbol, candidate)):
result.add(candidate)
result = list(result)
elif strategy == -1:
raise ValueError('Could not parse expression %s' % f)
# this is the fallback for not getting any other solution
if result is False or strategy == GS_TRANSCENDENTAL:
# reject any result that makes any dens affirmatively 0,
# if in doubt, keep it
soln = tsolve(f_num, symbol)
dens = denoms(f, x=symbols)
if not dens:
result = soln
else:
result = [s for s in soln if all(not checksol(den, {symbol: s}) for den in dens)]
if result is False:
raise NotImplementedError(msg + "\nNo algorithms are implemented to solve equation %s" % f)
if flags.get('simplified', True) and strategy != GS_RATIONAL:
result = map(simplify, result)
return result
else:
if not f:
return []
else:
# Create a swap dictionary for storing the passed symbols to be
# solved for, so that they may be swapped back.
if symbol_swapped:
swap_dict = zip(symbols, symbols_new)
f = [fi.subs(swap_dict) for fi in f]
symbols = symbols_new
polys = []
for g in f:
poly = g.as_poly(*symbols, extension=True)
if poly is not None:
polys.append(poly)
else:
raise NotImplementedError()
if all(p.is_linear for p in polys):
n, m = len(f), len(symbols)
matrix = zeros((n, m + 1))
for i, poly in enumerate(polys):
for monom, coeff in poly.terms():
try:
j = list(monom).index(1)
matrix[i, j] = coeff
except ValueError:
matrix[i, m] = -coeff
# a dictionary of symbols: values or None
soln = solve_linear_system(matrix, *symbols, **flags)
# Use swap_dict to ensure we return the same type as what was
# passed; this is not necessary in the poly-system case which
# only supports zero-dimensional systems
if symbol_swapped and soln:
soln = dict([(swap_back_dict[k],
v.subs(swap_back_dict))
for k, v in soln.iteritems()])
return soln
else:
# a list of tuples, T, where T[i] [j] corresponds to the ith solution for symbols[j]
return solve_poly_system(polys)
