ó 9­\c@ s¹dZddlmZmZddlmZddlmZmZm Z m Z m Z ddl m Z ddlmZmZmZmZmZmZmZmZmZddlmZddlmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(dd l)m*Z*m+Z+m,Z,dd l-m.Z.m/Z/m0Z0dd l1m2Z2m3Z3dd l4m5Z5ddl6m7Z7m8Z8m9Z9ddl:m;Z;ddl<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKddlLmMZMmNZNddlOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYddlZm[Z[ddl\m]Z]ddl^m_Z_m`Z`ddlambZbmcZcmdZdmeZemfZfmgZgddlhmiZimjZjddlkmlZlmmZmddlnmoZoddlpmqZqddlrmsZsmtZtmuZuddlvmwZwddlxmyZyddlzm{Z{ddl|m}Z}dd l~mZdd!l€mZdd"l‚Z‚d#„Zƒd$„Z„d%„Z…d&„Z†e‡d'„Zˆd(„Z‰e‡d)„ZŠd*„Z‹d+„ZŒd,„Zd-ggd.„ZŽd/„Zd0„Zd1„Z‘d2„Z’d3„Z“d4„Z”e‡d5„Z•d6„Z–id7„eA6d8„e@6Z—d9„Z˜ewd:„ƒZ™d;„Zšd<„Z›dd=lœmZmžZžmŸZŸd"S(>s This module contain solvers for all kinds of equations: - algebraic or transcendental, use solve() - recurrence, use rsolve() - differential, use dsolve() - nonlinear (numerically), use nsolve() (you will need a good starting point) iÿÿÿÿ(tprint_functiontdivision(tdivisors(titerablet is_sequencetorderedtdefault_sort_keytrange(tsympify( tStAddtSymboltEqualitytDummytExprtMultPowt Unequality(t factor_terms( t expand_multexpand_multinomialt expand_logt Derivativet AppliedUndeftUndefinedFunctiontnfloattFunctiontexpand_power_exptLambdat_mexpandtexpand(tIntegral(tilcmtFloattRational(t RelationaltGet _canonical(t fuzzy_nott fuzzy_and(t integer_log(tAndtOrt BooleanAtom(tpreorder_traversal(tlogtexptLambertWtcostsinttantacostasintatantAbstretimtargtsqrttatan2(tTrigonometricFunctiontHyperbolicFunction( tsimplifytcollecttpowsimptposifyt powdenestt nsimplifytdenomt logcombinet sqrtdenesttfraction(t sqrt_depth(tTR1(tMatrixtzeros(trootstcanceltfactortPolyttogethertdegree(tGeneratorsNeededtPolynomialError(tpiecewise_foldt Piecewise(tlambdify(t filldedent(tuniqt generate_belltflatten(tconserve_mpmath_dps(tfindroot(tsolve_poly_system(treduce_inequalities(t GeneratorType(t defaultdictNcC st|ƒ r(t|ƒr(tdƒ‚nt|ƒ}i}x[t|ƒD]M\}}t|tƒ rG||krGtd|ƒ||<||||>> from sympy.solvers.solvers import recast_to_symbols >>> from sympy import symbols, Function >>> x, y = symbols('x y') >>> fx = Function('f')(x) >>> eqs, syms = [fx + 1, x, y], [fx, y] >>> e, s, d = recast_to_symbols(eqs, syms); (e, s, d) ([_X0 + 1, x, y], [_X0, y], {_X0: f(x)}) The original equations and symbols can be restored using d: >>> assert [i.xreplace(d) for i in eqs] == eqs >>> assert [d.get(i, i) for i in s] == syms s%Both eqs and symbols must be iterablesX%dtsubscS si|]\}}||“qS(((t.0tktv((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ds N( Rt ValueErrortlistt enumeratet isinstanceR R tgetattrtNonetappendtitems(teqstsymbolst new_symbolstswap_symtitstnew_ftisubs((s4lib/python2.7/site-packages/sympy/solvers/solvers.pytrecast_to_symbols?s    cC s%t|tƒo$|jp$t|tƒS(s$Return True if e is a Pow or is exp.(RhRtis_PowR.(te((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt_ispowhscC sgtƒ}xWt||ƒD]F}|jrR|jjrR|jjrFqn|j}n|j|ƒqW|S(N(tsettdenomsRvR.t is_Numbertis_zerotbasetadd(tfRntdenstd((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt _simple_densms   c st|ƒ}tƒ}xV|D]N}t|ƒ}|tjkrCqnx$tj|ƒD]}|j|ƒqSWqW|sx|St|ƒdkrªt |dƒrª|d}qªng}xC|D];}|j ‰t ‡fd†|Dƒƒr·|j |ƒq·q·Wt|ƒS(spReturn (recursively) set of all denominators that appear in eq that contain any symbol in ``symbols``; if ``symbols`` are not provided then all denominators will be returned. Examples ======== >>> from sympy.solvers.solvers import denoms >>> from sympy.abc import x, y, z >>> from sympy import sqrt >>> denoms(x/y) {y} >>> denoms(x/(y*z)) {y, z} >>> denoms(3/x + y/z) {x, z} >>> denoms(x/2 + y/z) {2, z} If `symbols` are provided then only denominators containing those symbols will be returned >>> denoms(1/x + 1/y + 1/z, y, z) {y, z} iic3 s|]}|ˆkVqdS(N((RbRr(tfree(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys «s( R,RyRDR tOneRt make_argsR~tlenRt free_symbolstanyRk(teqRntpotR€tptdenRtrv((Rƒs4lib/python2.7/site-packages/sympy/solvers/solvers.pyRz|s&      c s¶ddlm}|jdtƒ}|dk r>i||6}n4t|tƒrV|}nd}t|||fƒ‚t|ƒrâ|s“tdƒ‚nt }xB|D]:}t |||} | rÄq n| tkrÔtSd}q W|St|t ƒr|j ƒ}n©t|t tfƒr©|jtjtjfkr<|j}n|j\} } | tjtjfkr‘|j|ƒ}|tjtjfkr¦dSq©|jtdtƒ}nt|tƒrÂt|ƒS|j r×| r×t S|rû|jt|jƒƒ@ rûdSttjtjtj tj!gƒ‰t"‡fd†|j#ƒDƒƒrEtS|} d} |jd t ƒ}x&| d 7} | d krÇ|j|ƒ}t|t$ƒr°|j%|ƒd }n|j&ƒˆ@rþtSn7| d kr6|j'sþ|j(d | t)|jƒƒŒstS|j*ƒ\}}t+|j,ƒd d t ƒ}qþnÈ| dkré|rLdS|jd t ƒr†x%|D]}t-||ƒ||j?d|ƒndS(s€Checks whether sol is a solution of equation f == 0. Input can be either a single symbol and corresponding value or a dictionary of symbols and values. When given as a dictionary and flag ``simplify=True``, the values in the dictionary will be simplified. ``f`` can be a single equation or an iterable of equations. A solution must satisfy all equations in ``f`` to be considered valid; if a solution does not satisfy any equation, False is returned; if one or more checks are inconclusive (and none are False) then None is returned. Examples ======== >>> from sympy import symbols >>> from sympy.solvers import checksol >>> x, y = symbols('x,y') >>> checksol(x**4 - 1, x, 1) True >>> checksol(x**4 - 1, x, 0) False >>> checksol(x**2 + y**2 - 5**2, {x: 3, y: 4}) True To check if an expression is zero using checksol, pass it as ``f`` and send an empty dictionary for ``symbol``: >>> checksol(x**2 + x - x*(x + 1), {}) True None is returned if checksol() could not conclude. flags: 'numerical=True (default)' do a fast numerical check if ``f`` has only one symbol. 'minimal=True (default is False)' a very fast, minimal testing. 'warn=True (default is False)' show a warning if checksol() could not conclude. 'simplify=True (default)' simplify solution before substituting into function and simplify the function before trying specific simplifications 'force=True (default is False)' make positive all symbols without assumptions regarding sign. iÿÿÿÿ(tUnittminimals;Expecting (sym, val) or ({sym: val}, None) but got (%s, %s)sno functions to checkNtevaluatec3 s+|]!\}}t|ƒjƒˆ@VqdS(N(Rtatoms(RbRcRd(tillegal(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys st numericaliiR>t recursiveitforceii tchopg•Ö&è .>twarns( Warning: could not verify solution %s.(@tsympy.physics.unitsRŽtgettFalseRjRhtdictReRtTruetchecksolROtas_exprR RtrhsR ttruetfalsetreversedtargsRatrewriteR R+tboolt is_RelationalR‡RytkeystNaNtComplexInfinitytInfinitytNegativeInfinityRˆRlRtas_independentR‘t is_numbert is_constantRftas_content_primitiveRtas_numer_denomR>RAR,RR~RvR.t is_Integert is_FunctionRR&R|thasR/t is_RationaltabstntwarningsR—(RtsymboltsoltflagsRŽRtmsgRtfitchecktBtEtwastattemptR“tvalt_RctrepstexvalRŠtseent saw_pow_funcR‹tnz((R’s4lib/python2.7/site-packages/sympy/solvers/solvers.pyR°sØ/          "    ""                 . cK sft|ƒ}i}xMt|jƒƒD]9}t|d|dƒ}|||k r%|||>> from sympy import failing_assumptions, Symbol >>> x = Symbol('x', real=True, positive=True) >>> y = Symbol('y') >>> failing_assumptions(6*x + y, real=True, positive=True) {'positive': None, 'real': None} >>> failing_assumptions(x**2 - 1, positive=True) {'positive': None} If all assumptions satisfy the `expr` an empty dictionary is returned. >>> failing_assumptions(x**2, positive=True) {} sis_%sN(RRfR§RiRj(texprt assumptionstfailedtkeyttest((s4lib/python2.7/site-packages/sympy/solvers/solvers.pytfailing_assumptionsos c s}tˆƒ‰|rQt|tƒs0tdƒ‚nˆrEtdƒ‚n|j‰n‡‡fd†‰t‡fd†ˆDƒƒS(sˆChecks whether expression `expr` satisfies all assumptions. `assumptions` is a dict of assumptions: {'assumption': True|False, ...}. Examples ======== >>> from sympy import Symbol, pi, I, exp, check_assumptions >>> check_assumptions(-5, integer=True) True >>> check_assumptions(pi, real=True, integer=False) True >>> check_assumptions(pi, real=True, negative=True) False >>> check_assumptions(exp(I*pi/7), real=False) True >>> x = Symbol('x', real=True, positive=True) >>> check_assumptions(2*x + 1, real=True, positive=True) True >>> check_assumptions(-2*x - 5, real=True, positive=True) False To check assumptions of ``expr`` against another variable or expression, pass the expression or variable as ``against``. >>> check_assumptions(2*x + 1, x) True `None` is returned if check_assumptions() could not conclude. >>> check_assumptions(2*x - 1, real=True, positive=True) >>> z = Symbol('z') >>> check_assumptions(z, real=True) See Also ======== failing_assumptions s against should be of type Symbols"No assumptions should be specifiedc s4tˆd|dƒ}|dk r0ˆ||kSdS(Ntis_(RiRj(RÌRd(RÊRÉ(s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt_test¾s c3 s|]}ˆ|ƒVqdS(N((RbRÌ(RÐ(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys Âs(RRhR t TypeErrortAssertionErrort assumptions0R'(RÉtagainstRÊ((RÐRÊRÉs4lib/python2.7/site-packages/sympy/solvers/solvers.pytcheck_assumptionsŽs)  c-  sMd„‰t|ƒ }ˆoLˆdoLtˆdtƒpLtˆddtƒ}‡fd†|ˆgDƒ\}‰t|tƒr·g|D]'‰ˆtjk o¥ˆtk r®ˆ^q‡}n|j dt ƒ}ˆ r‰t ƒj g|D]}|j ^qàŒ‰tˆƒt|ƒkrtx^|D]V}t|ƒ}xA|D]9}t|tƒrit|d<ˆj|ƒ|jƒnq0WqWntˆƒ‰t }n/tˆƒdko¨tˆdƒr¸ˆd‰n|jdt ƒƒ} | rt| tƒrî| g} nt ƒj gt| ƒD]} | j ^qŒ} ngˆD]‰ˆ| kr>ˆ^q&‰xÊt|ƒD]¼\} }t|ttfƒr³d g|jD]} t| ƒj^qkr°|j|j}nö|j} | dtjtjfkrì| d| df} n| \}}|tjtjfkr‘t|tƒr)|}n|jrQ|tjkrH|n|}n=|j ra|Sn-|j!oq|j r||Snt"t#d ƒƒ‚n|j$t%d t ƒ}||| ƒfƒq¹W|j?|ƒ}g|j/t2ƒD]} | j:ˆŒr†| ^qk}|j@tAttB|g|D]0} tCt1| jdƒt0| jdƒƒ^q¥ƒƒƒƒ}||| t1ˆƒfƒnqW|r x{|D]s\‰}x4t|ƒD]&\} }|j@i|ˆ6ƒ|| qn|&j=|!ƒ|)t<krg|%j=|!ƒnqWnt|tAƒrùt }*xp|jSƒD]F\}'}(t]|(|'j^})|)rºqn|)t krÐt<}&Pnt}*qW|}&|*rö|%j=|ƒnnyt|t_t`tafƒrftˆƒdkr2tbd"ƒ‚n|$oBˆdj^rctcjdt#d#ˆdƒƒnn ted$ƒ‚|&}|$o|%rµtcjdt#d%d&d'jfd(„|%Dƒƒƒƒnn|j dt ƒ}+|j dt ƒ},|, oït|tƒr|jgdtGƒn|+ o|, r |pgSn| r0g}n·t|tAƒrK|g}nœt|dƒrŒg|D]!‰tAttBˆˆƒƒƒ^qb}n[t|dtAƒr¢nEtˆƒdkrÃtbd"ƒ‚ng|D]‰iˆˆd6^qÊ}|+rô|Sn|,sth‚| rgt ƒfSntti|djjƒƒƒ‰ˆ‡fd)†|DƒfS(*s°> Algebraically solves equations and systems of equations. Currently supported are: - polynomial, - transcendental - piecewise combinations of the above - systems of linear and polynomial equations - systems containing relational expressions. Input is formed as: * f - a single Expr or Poly that must be zero, - an Equality - a Relational expression - a Boolean - iterable of one or more of the above * symbols (object(s) to solve for) specified as - none given (other non-numeric objects will be used) - single symbol - denested list of symbols e.g. solve(f, x, y) - ordered iterable of symbols e.g. solve(f, [x, y]) * flags 'dict'=True (default is False) return list (perhaps empty) of solution mappings 'set'=True (default is False) return list of symbols and set of tuple(s) of solution(s) 'exclude=[] (default)' don't try to solve for any of the free symbols in exclude; if expressions are given, the free symbols in them will be extracted automatically. 'check=True (default)' If False, don't do any testing of solutions. This can be useful if one wants to include solutions that make any denominator zero. 'numerical=True (default)' do a fast numerical check if ``f`` has only one symbol. 'minimal=True (default is False)' a very fast, minimal testing. 'warn=True (default is False)' show a warning if checksol() could not conclude. 'simplify=True (default)' simplify all but polynomials of order 3 or greater before returning them and (if check is not False) use the general simplify function on the solutions and the expression obtained when they are substituted into the function which should be zero 'force=True (default is False)' make positive all symbols without assumptions regarding sign. 'rational=True (default)' recast Floats as Rational; if this option is not used, the system containing floats may fail to solve because of issues with polys. If rational=None, Floats will be recast as rationals but the answer will be recast as Floats. If the flag is False then nothing will be done to the Floats. 'manual=True (default is False)' do not use the polys/matrix method to solve a system of equations, solve them one at a time as you might "manually" 'implicit=True (default is False)' allows solve to return a solution for a pattern in terms of other functions that contain that pattern; this is only needed if the pattern is inside of some invertible function like cos, exp, .... 'particular=True (default is False)' instructs solve to try to find a particular solution to a linear system with as many zeros as possible; this is very expensive 'quick=True (default is False)' when using particular=True, use a fast heuristic instead to find a solution with many zeros (instead of using the very slow method guaranteed to find the largest number of zeros possible) 'cubics=True (default)' return explicit solutions when cubic expressions are encountered 'quartics=True (default)' return explicit solutions when quartic expressions are encountered 'quintics=True (default)' return explicit solutions (if possible) when quintic expressions are encountered Examples ======== The output varies according to the input and can be seen by example:: >>> from sympy import solve, Poly, Eq, Function, exp >>> from sympy.abc import x, y, z, a, b >>> f = Function('f') * boolean or univariate Relational >>> solve(x < 3) (-oo < x) & (x < 3) * to always get a list of solution mappings, use flag dict=True >>> solve(x - 3, dict=True) [{x: 3}] >>> sol = solve([x - 3, y - 1], dict=True) >>> sol [{x: 3, y: 1}] >>> sol[0][x] 3 >>> sol[0][y] 1 * to get a list of symbols and set of solution(s) use flag set=True >>> solve([x**2 - 3, y - 1], set=True) ([x, y], {(-sqrt(3), 1), (sqrt(3), 1)}) * single expression and single symbol that is in the expression >>> solve(x - y, x) [y] >>> solve(x - 3, x) [3] >>> solve(Eq(x, 3), x) [3] >>> solve(Poly(x - 3), x) [3] >>> solve(x**2 - y**2, x, set=True) ([x], {(-y,), (y,)}) >>> solve(x**4 - 1, x, set=True) ([x], {(-1,), (1,), (-I,), (I,)}) * single expression with no symbol that is in the expression >>> solve(3, x) [] >>> solve(x - 3, y) [] * single expression with no symbol given In this case, all free symbols will be selected as potential symbols to solve for. If the equation is univariate then a list of solutions is returned; otherwise -- as is the case when symbols are given as an iterable of length > 1 -- a list of mappings will be returned. >>> solve(x - 3) [3] >>> solve(x**2 - y**2) [{x: -y}, {x: y}] >>> solve(z**2*x**2 - z**2*y**2) [{x: -y}, {x: y}, {z: 0}] >>> solve(z**2*x - z**2*y**2) [{x: y**2}, {z: 0}] * when an object other than a Symbol is given as a symbol, it is isolated algebraically and an implicit solution may be obtained. This is mostly provided as a convenience to save one from replacing the object with a Symbol and solving for that Symbol. It will only work if the specified object can be replaced with a Symbol using the subs method. >>> solve(f(x) - x, f(x)) [x] >>> solve(f(x).diff(x) - f(x) - x, f(x).diff(x)) [x + f(x)] >>> solve(f(x).diff(x) - f(x) - x, f(x)) [-x + Derivative(f(x), x)] >>> solve(x + exp(x)**2, exp(x), set=True) ([exp(x)], {(-sqrt(-x),), (sqrt(-x),)}) >>> from sympy import Indexed, IndexedBase, Tuple, sqrt >>> A = IndexedBase('A') >>> eqs = Tuple(A[1] + A[2] - 3, A[1] - A[2] + 1) >>> solve(eqs, eqs.atoms(Indexed)) {A[1]: 1, A[2]: 2} * To solve for a *symbol* implicitly, use 'implicit=True': >>> solve(x + exp(x), x) [-LambertW(1)] >>> solve(x + exp(x), x, implicit=True) [-exp(x)] * It is possible to solve for anything that can be targeted with subs: >>> solve(x + 2 + sqrt(3), x + 2) [-sqrt(3)] >>> solve((x + 2 + sqrt(3), x + 4 + y), y, x + 2) {y: -2 + sqrt(3), x + 2: -sqrt(3)} * Nothing heroic is done in this implicit solving so you may end up with a symbol still in the solution: >>> eqs = (x*y + 3*y + sqrt(3), x + 4 + y) >>> solve(eqs, y, x + 2) {y: -sqrt(3)/(x + 3), x + 2: (-2*x - 6 + sqrt(3))/(x + 3)} >>> solve(eqs, y*x, x) {x: -y - 4, x*y: -3*y - sqrt(3)} * if you attempt to solve for a number remember that the number you have obtained does not necessarily mean that the value is equivalent to the expression obtained: >>> solve(sqrt(2) - 1, 1) [sqrt(2)] >>> solve(x - y + 1, 1) # /!\ -1 is targeted, too [x/(y - 1)] >>> [_.subs(z, -1) for _ in solve((x - y + 1).subs(-1, z), 1)] [-x + y] * To solve for a function within a derivative, use dsolve. * single expression and more than 1 symbol * when there is a linear solution >>> solve(x - y**2, x, y) [(y**2, y)] >>> solve(x**2 - y, x, y) [(x, x**2)] >>> solve(x**2 - y, x, y, dict=True) [{y: x**2}] * when undetermined coefficients are identified * that are linear >>> solve((a + b)*x - b + 2, a, b) {a: -2, b: 2} * that are nonlinear >>> solve((a + b)*x - b**2 + 2, a, b, set=True) ([a, b], {(-sqrt(2), sqrt(2)), (sqrt(2), -sqrt(2))}) * if there is no linear solution then the first successful attempt for a nonlinear solution will be returned >>> solve(x**2 - y**2, x, y, dict=True) [{x: -y}, {x: y}] >>> solve(x**2 - y**2/exp(x), x, y, dict=True) [{x: 2*LambertW(y/2)}] >>> solve(x**2 - y**2/exp(x), y, x) [(-x*sqrt(exp(x)), x), (x*sqrt(exp(x)), x)] * iterable of one or more of the above * involving relationals or bools >>> solve([x < 3, x - 2]) Eq(x, 2) >>> solve([x > 3, x - 2]) False * when the system is linear * with a solution >>> solve([x - 3], x) {x: 3} >>> solve((x + 5*y - 2, -3*x + 6*y - 15), x, y) {x: -3, y: 1} >>> solve((x + 5*y - 2, -3*x + 6*y - 15), x, y, z) {x: -3, y: 1} >>> solve((x + 5*y - 2, -3*x + 6*y - z), z, x, y) {x: 2 - 5*y, z: 21*y - 6} * without a solution >>> solve([x + 3, x - 3]) [] * when the system is not linear >>> solve([x**2 + y -2, y**2 - 4], x, y, set=True) ([x, y], {(-2, -2), (0, 2), (2, -2)}) * if no symbols are given, all free symbols will be selected and a list of mappings returned >>> solve([x - 2, x**2 + y]) [{x: 2, y: -4}] >>> solve([x - 2, x**2 + f(x)], {f(x), x}) [{x: 2, f(x): -4}] * if any equation doesn't depend on the symbol(s) given it will be eliminated from the equation set and an answer may be given implicitly in terms of variables that were not of interest >>> solve([x - y, y - 3], x) {x: y} Notes ===== solve() with check=True (default) will run through the symbol tags to elimate unwanted solutions. If no assumptions are included all possible solutions will be returned. >>> from sympy import Symbol, solve >>> x = Symbol("x") >>> solve(x**2 - 1) [-1, 1] By using the positive tag only one solution will be returned: >>> pos = Symbol("pos", positive=True) >>> solve(pos**2 - 1) [1] Assumptions aren't checked when `solve()` input involves relationals or bools. When the solutions are checked, those that make any denominator zero are automatically excluded. If you do not want to exclude such solutions then use the check=False option: >>> from sympy import sin, limit >>> solve(sin(x)/x) # 0 is excluded [pi] If check=False then a solution to the numerator being zero is found: x = 0. In this case, this is a spurious solution since sin(x)/x has the well known limit (without dicontinuity) of 1 at x = 0: >>> solve(sin(x)/x, check=False) [0, pi] In the following case, however, the limit exists and is equal to the value of x = 0 that is excluded when check=True: >>> eq = x**2*(1/x - z**2/x) >>> solve(eq, x) [] >>> solve(eq, x, check=False) [0] >>> limit(eq, x, 0, '-') 0 >>> limit(eq, x, 0, '+') 0 Disabling high-order, explicit solutions ---------------------------------------- When solving polynomial expressions, one might not want explicit solutions (which can be quite long). If the expression is univariate, CRootOf instances will be returned instead: >>> solve(x**3 - x + 1) [-1/((-1/2 - sqrt(3)*I/2)*(3*sqrt(69)/2 + 27/2)**(1/3)) - (-1/2 - sqrt(3)*I/2)*(3*sqrt(69)/2 + 27/2)**(1/3)/3, -(-1/2 + sqrt(3)*I/2)*(3*sqrt(69)/2 + 27/2)**(1/3)/3 - 1/((-1/2 + sqrt(3)*I/2)*(3*sqrt(69)/2 + 27/2)**(1/3)), -(3*sqrt(69)/2 + 27/2)**(1/3)/3 - 1/(3*sqrt(69)/2 + 27/2)**(1/3)] >>> solve(x**3 - x + 1, cubics=False) [CRootOf(x**3 - x + 1, 0), CRootOf(x**3 - x + 1, 1), CRootOf(x**3 - x + 1, 2)] If the expression is multivariate, no solution might be returned: >>> solve(x**3 - x + a, x, cubics=False) [] Sometimes solutions will be obtained even when a flag is False because the expression could be factored. In the following example, the equation can be factored as the product of a linear and a quadratic factor so explicit solutions (which did not require solving a cubic expression) are obtained: >>> eq = x**3 + 3*x**2 + x - 1 >>> solve(eq, cubics=False) [-1, -1 + sqrt(2), -sqrt(2) - 1] Solving equations involving radicals ------------------------------------ Because of SymPy's use of the principle root (issue #8789), some solutions to radical equations will be missed unless check=False: >>> from sympy import root >>> eq = root(x**3 - 3*x**2, 3) + 1 - x >>> solve(eq) [] >>> solve(eq, check=False) [1/3] In the above example there is only a single solution to the equation. Other expressions will yield spurious roots which must be checked manually; roots which give a negative argument to odd-powered radicals will also need special checking: >>> from sympy import real_root, S >>> eq = root(x, 3) - root(x, 5) + S(1)/7 >>> solve(eq) # this gives 2 solutions but misses a 3rd [CRootOf(7*_p**5 - 7*_p**3 + 1, 1)**15, CRootOf(7*_p**5 - 7*_p**3 + 1, 2)**15] >>> sol = solve(eq, check=False) >>> [abs(eq.subs(x,i).n(2)) for i in sol] [0.48, 0.e-110, 0.e-110, 0.052, 0.052] The first solution is negative so real_root must be used to see that it satisfies the expression: >>> abs(real_root(eq.subs(x, sol[0])).n(2)) 0.e-110 If the roots of the equation are not real then more care will be necessary to find the roots, especially for higher order equations. Consider the following expression: >>> expr = root(x, 3) - root(x, 5) We will construct a known value for this expression at x = 3 by selecting the 1-th root for each radical: >>> expr1 = root(x, 3, 1) - root(x, 5, 1) >>> v = expr1.subs(x, -3) The solve function is unable to find any exact roots to this equation: >>> eq = Eq(expr, v); eq1 = Eq(expr1, v) >>> solve(eq, check=False), solve(eq1, check=False) ([], []) The function unrad, however, can be used to get a form of the equation for which numerical roots can be found: >>> from sympy.solvers.solvers import unrad >>> from sympy import nroots >>> e, (p, cov) = unrad(eq) >>> pvals = nroots(e) >>> inversion = solve(cov, x)[0] >>> xvals = [inversion.subs(p, i) for i in pvals] Although eq or eq1 could have been used to find xvals, the solution can only be verified with expr1: >>> z = expr - v >>> [xi.n(chop=1e-9) for xi in xvals if abs(z.subs(x, xi).n()) < 1e-9] [] >>> z1 = expr1 - v >>> [xi.n(chop=1e-9) for xi in xvals if abs(z1.subs(x, xi).n()) < 1e-9] [-3.0] See Also ======== - rsolve() for solving recurrence relationships - dsolve() for solving differential equations cS s(tttt|ƒr|n|gƒƒS(N(RftmapRR(tw((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt_sympified_listsitincludec3 s|]}ˆ|ƒVqdS(N((RbR×(RØ(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys šstimplicitR›itexcludetImmutableDenseMatrixs Unanticipated argument of Eq when other arg is True or False. RRncS s t|tƒS(N(RhR=(R×((s4lib/python2.7/site-packages/sympy/solvers/solvers.pytßtcS s |jtƒS(N(R¤R.(R×((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRÝàRÞcs s!|]}|jp|jVqdS(N(tis_realt is_imaginary(RbRr((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys êsc3 s+|]!}|jttttƒˆVqdS(N(R‘R7R8R9R;(RbRq(thad(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ïscs s$|]}t|ttfƒVqdS(N(RhR¥R+(RbR¼((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys õsRyR×s6solving %s when the argument is not real or imaginary.c3 s-|]#}|jtˆƒtˆƒƒVqdS(N(R³R7R8(RbR¼(Rr(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys sRÌtrationalt _denominatorsc s<|jr|jˆŒStg|jD]}ˆ|ƒ^q#ƒS(N(t is_PiecewiseR³RˆR£(Rwta(t_has_piecewiseRn(s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRæ‡s  c s‡fd†|jƒDƒS(Nc s(i|]\}}|jˆƒ|“qS((Ra(RbRcRd(t non_inverts(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys žs (Rl(tsolution(Rç(s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt_do_dicts s> no handling of %s was implementedc s4i|]*\}}|jˆƒˆj||ƒ“qS((RaR™(RbRcRd(Rp(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys Ás c s4i|]*\}}|jˆƒˆj||ƒ“qS((RaR™(RbRcRd(Rp(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys Ås cs s|]}t|tƒVqdS(N(RhR›(RbR¹((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ÏsR½texponentR—sLength should be 1sm Warning: assumptions about variable '%s' are not handled currently.sUnrecognized solutionsi Warning: assumptions concerning following solution(s) can't be checked:s s, cs s|]}t|ƒVqdS(N(tstr(RbRr((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys 'sc s3h|])}tgˆD]}||^qƒ’qS((ttuple(RbRrtki(Rc(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys Ks (kRRhR RR_RfR R RœR™RšRytunionR‡R†R,RR~tskiptpopRRRgR RR£ttypet__name__tlhsRŸR¡R¦t is_Symbolt is_BooleantNotImplementedErrorRWR¤R R^RORžtreplacet is_MatrixtextendtZerotallt as_real_imagR‘R7R8R9R;RˆR RRUR$R6R³RßRjRkt ImaginaryUnitRatxreplaceR›tzipR5RàRXtsortedRRuR­R{R|R®R¥tis_Addtis_MulRvR²tfuncRlR!RCR‚RTt_solvet _solve_systemRRìRRÕRÓR#R)R*ReR·R—RÑtjointsortRÒRR§(-RRnRºtbare_ftordered_symbolsRÚR¼RŠR‹RÛRwRqRåR£tLtRtfreeitfrR×tpieceRÄt_argtirfRŸtsymsettnewftokRÆRÃRdtfloatsRèRéR¹trR½R—tgot_Nonetno_FalsetsymbRÂRÍta_Nonetas_dicttas_set((RæRØRáRcRçRrRpRns4lib/python2.7/site-packages/sympy/solvers/solvers.pytsolveÅsLÿÌ     "7(       "  1%+           ! . ,"1I 1#                  %   1"=   8" % ( G$                  $   1$ c= sÀd}t|ƒdkr®d*‰|j}|t|ƒ}t|ƒdkrq|j|Œ\}}|j|j@}nt|ƒdkr¿|jƒ}yt|||ˆ‰Wq¿tk r»q¿Xnˆrþˆjdt ƒrút ˆt ƒrxˆD]}t ˆ|ƒˆ|d$ƒƒ‚qR qg Xnt ˆj?ƒƒ‰ˆd*k r< |$j@}3|3ˆkrð yKt5dƒ‰t|3ˆˆˆ}7t t4‡‡fd%†|7Dƒƒƒ‰Wqö tk rì d*‰qö Xnt}ˆd*k r9 tˆƒdkr- ˆjdtƒˆdics s|]}t|ƒVqdS(N(R>(RbRq((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys tssunrecognized args in listcS s&h|]}td„|Dƒƒ’qS(cs s|]}t|ƒVqdS(N(R>(RbRq((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ys(Rì(Rbtj((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ys sunrecognized solution typeRnR½Rãc3 s)|]}t|iˆˆ6ˆ VqdS(N(R(RbRŒ(RºRrR¸(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ¶ss)solve cannot represent interval solutionst _eval_simpifytratioitmeasurecS sdS(Ni((tx((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRÝÑRÞRÞscould not convert %s to Polys#expression appears to be a constantcS s€|jƒ\}}|jr(||jfS|js;|dfS|jƒ\}}|jrv|tjk rv|||jfS|dfS(s”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) i(t as_base_expR´tqRt as_coeff_MulR R„(R!tbRwtctee((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt _as_base_qs    cs s|]}|dkVqdS(iN((RbR#((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys scs s|]}|jr|VqdS(N(R²(RbR%((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys sttsmultiple generators %scS s,|jƒ\}}t|ƒ}t||ƒS(N(R"RR(R‹R%Rw((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt_expandUs cS s|jpt|tƒS(N(RvRhR.(R×((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRÝZRÞt compositettsolvec s%i|]}ˆj|tƒ|“qS((R™Rœ(RbRc(Rº(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ts tcubicstquarticstquinticst incompletes Neither high-order multivariate polynomials nor sorting of EX-domain polynomials is supported. If you want to see any results, pass keyword incomplete=True to solve; to see numerical values of roots for univariate expressions, use nroots. c s/h|]%}ˆD]}|jˆ|ƒ’qqS((Ra(RbRqRr(tsolnR)(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ”s t_unradc s"h|]}ˆjˆ|ƒ’qS((Ra(Rbtxi(tinvtisym(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ´s s c3 s)|]}t|iˆˆ6ˆ VqdS(N(R(RbR(RºRrR¸(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ÛsN(R-R.R/(GR†RjR‡RyR¬Rðtsolve_undetermined_coeffsRöR™RœRhR›R>RfRìRÑt solve_linearRˆR~RkRRR£R R«R©RªtupdateR‚RûRšRäRgR|R)RaRiRUR¨RúRôROReRRtgensR³RÿR<t intersectionRIR¤R2RR RR.R÷RQRLtsumtvaluest all_rootsRWR§tgentunradt_tsolveRSRRÖR(=RRnRºt not_impl_msgRƒtextindtdepRcRRtsymtsolsRËtgot_stresultR3RdtvfreetssR¹t checkdensR½tmR€RqRÉtcondt candidatesRÃR&R£t candidateRtf_numR»tpolyt simplified_ftgR9R(tbasestqstfuncsttrigtotherRtf1tftrytcv_solstcv_invtuR*tdegtsolverstivR‰tcovtieqRR((RºR4R5RrR1R¸R)s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRNsè       ,     +   .      $      "  .                +  1 ) "             !          )       (        "   .c- s|s gSg}tƒ}g}t}t}ˆjdtƒ}ˆjdtƒ} } x¶t|ƒD]¨\} } |jt| |ƒƒt| |Œ\} }|| } | jƒd} |rÊ|j | ƒq`n| j dt|Œ}|dk rû|j |ƒq`|j | ƒq`W|sg‰nNt d„|DƒƒrKt |ƒt |ƒ}}t||dƒ}xt|ƒD]q\} }xb|jƒD]T\}}y#|jdƒ} ||| | fsit particulariÿÿÿÿ(tsubsetssno valid subset foundc s:|jˆˆ@}|r6t|ƒ}|jdtƒn|S(NRÌ(R‡RfRR(RwRR(tlegalt solved_syms(s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt_ok_symsUs  c stˆ|ƒƒS(N(R†(RÃ(Rj(s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRÝ`RÞRRscould not solve %sR>c3 s!|]}t|ˆˆVqdS(N(R(RbR(RºR(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ¡sc3 s'|]}t|ˆˆtkVqdS(N(RRš(RbRw(RºR(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ¥s(/RyRšR™RœRgR8R‚t_invertR°Rktas_polyRjRûR†RKttermstindexReRðtminsolve_linear_systemtsolve_linear_systemRfR§tsympy.utilities.iterablesRgRîR‡RR:R]RˆRùR›RÿRöRžRhR RaRRtcopyRlR~tremoveR¥R>(-texprsRnRºtpolysR€RËRHtlinearRcRKR½RRSRqRRQR¶RLtmatrixtmonomtcoeffRgR‹RƒRGtsymstresRïtr1RJR]R‰t newresultt bad_resultsthitteq2R%tok_symsRrR1R¹trnewRcRdtdefault_simplify((RjRºRhRRis4lib/python2.7/site-packages/sympy/solvers/solvers.pyRäs        (    "  3 5 &              .         .  .  ic s†t|tƒrC|r.ttd|ƒƒ‚n|j}|j}nd }||}|jƒ\}}|s{tj tj fS|j }|s“|}n´g|D]} | j sš| ^qš} | r8t | ƒdkrÚ| d} nt |ƒdkrd||df} nd|t|ƒf} ttd| | fƒƒ‚n|j|ƒ}|j|ƒ}|sltj tj fS|j } ttƒ} xF|jtƒD]5}|j |@}x|D]}| |j|ƒq«Wq‘Wt}xzt|dtƒD]f‰t| ˆtƒrd„| ˆDƒ| ˆ>> from sympy.solvers.solvers import solve_linear >>> from sympy.abc import x, y, z >>> from sympy import cos, sin >>> eq = y*cos(x)**2 + y*sin(x)**2 - y # = y*(1 - 1) = 0 >>> solve_linear(eq) (0, 1) >>> eq = cos(x)**2 + sin(x)**2 # = 1 >>> solve_linear(eq) (0, 1) >>> solve_linear(x, exclude=[x]) (0, 1) (0, 0) meaning that there is no solution to the equation amongst the symbols given. (If the first element of the tuple is not zero then the function is guaranteed to be dependent on a symbol in ``symbols``.) (symbol, solution) where symbol appears linearly in the numerator of ``f``, is in ``symbols`` (if given) and is not in ``exclude`` (if given). No simplification is done to ``f`` other than a ``mul=True`` expansion, so the solution will correspond strictly to a unique solution. ``(n, d)`` where ``n`` and ``d`` are the numerator and denominator of ``f`` when the numerator was not linear in any symbol of interest; ``n`` will never be a symbol unless a solution for that symbol was found (in which case the second element is the solution, not the denominator). Examples ======== >>> from sympy.core.power import Pow >>> from sympy.polys.polytools import cancel The variable ``x`` appears as a linear variable in each of the following: >>> solve_linear(x + y**2) (x, -y**2) >>> solve_linear(1/x - y**2) (x, y**(-2)) When not linear in x or y then the numerator and denominator are returned. >>> solve_linear(x**2/y**2 - 3) (x**2 - 3*y**2, y**2) If the numerator of the expression is a symbol then (0, 0) is returned if the solution for that symbol would have set any denominator to 0: >>> eq = 1/(1/x - 2) >>> eq.as_numer_denom() (x, 1 - 2*x) >>> solve_linear(eq) (0, 0) But automatic rewriting may cause a symbol in the denominator to appear in the numerator so a solution will be returned: >>> (1/x)**-1 x >>> solve_linear((1/x)**-1) (x, 0) Use an unevaluated expression to avoid this: >>> solve_linear(Pow(1/x, -1, evaluate=False)) (0, 0) If ``x`` is allowed to cancel in the following expression, then it appears to be linear in ``x``, but this sort of cancellation is not done by ``solve_linear`` so the solution will always satisfy the original expression without causing a division by zero error. >>> eq = x**2*(1/x - z**2/x) >>> solve_linear(cancel(eq)) (x, 0) >>> solve_linear(eq) (x**2*(1 - z**2), x) A list of symbols for which a solution is desired may be given: >>> solve_linear(x + y + z, symbols=[y]) (y, -x - z) A list of symbols to ignore may also be given: >>> solve_linear(x + y + z, exclude=[x]) (y, -x - z) (A solution for ``y`` is obtained because it is the first variable from the canonically sorted list of symbols that had a linear solution.) s< If lhs is an Equality, rhs must be 0 but was %siis solve(%s, %s)ssolve(%s, *%s)sœ solve_linear only handles symbols, not %s. To isolate non-symbols use solve, e.g. >>> %s <<<. RÌcS si|]}|jƒ|“qS((tdoit(Rbtder((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys Gs c3 s|]}ˆj|ƒVqdS(N(tdiff(RbRr(t dnewn_dxi(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys Msiÿÿÿÿc3 s1|]'}t|iˆˆ6dtƒtkVqdS(RN(RRœ(Rbtdi(tviR3(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys UsN(#RhR ReRWRŸRóRjR°R RúR„R‡RôR†RfR:t differenceR`R‘RRkRœRRRaR†RˆRšR¨R‚RtfunctionR­R„R(RóRŸRnRÛR€R‰R¶RRƒRrtbadtegtdfreetderivsR…tcsymR&tall_zerotnewnRqtirep((R‡R‰R3s4lib/python2.7/site-packages/sympy/solvers/solvers.pyR7­svk     "      )  $ c sŠ|jdtƒ}t|||Ž}| sGtd„|jƒDƒƒrK|S|rZt||Œ}d„}i}|||ƒx×|rUtd„|jƒDƒdd„ƒ}t|jdtƒ‰t|jƒdkrçt dƒ|ˆoscS s}g}xX|jƒD]J\}}|j|ƒ||<||js|j|ƒ||||‚sRÌcS st|jƒt|ƒfS(N(R†R‡R(R!((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyR݃RÞiic3 s'|]}|jˆˆƒdkVqdS(iN(Ra(RbRd(RÂR!(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ‰siÿÿÿÿ(t combinations(tdebugs minsolve: %scs s|]}|dkVqdS(iN((RbRd((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ¢sN(R™RšRpRûR<tmaxR‡RR†R Rt itertoolsR—tsympy.utilities.miscR˜RoRœRRjRfRJtcoltTRlRaRn(tsystemRnRºR”ts0RrR8R•RcR—R˜tNtbestsoltn0R¶tthissoltnonzerosRqtsubmRdRaRE((RÂR!s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRods^#    1   1"A&#)    c s´|jdtƒ}|j|jdko9t|ƒknrúy¥t|dd…dd…fƒ}tt|||dd…dfƒƒ}|rÂx-|jƒD]\}}t |ƒ||>> from sympy import Matrix, solve_linear_system >>> from sympy.abc import x, y Solve the following system:: x + 4 y == 2 -2 x + y == 14 >>> system = Matrix(( (1, 4, 2), (-2, 1, 14))) >>> solve_linear_system(system, x, y) {x: -6, y: 2} A degenerate system returns an empty dictionary. >>> system = Matrix(( (0,0,0), (0,0,0) )) >>> solve_linear_system(system, x, y) {} R>iNiÿÿÿÿcs s|]}|jVqdS(N(R|(RbRq((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys æsic s|ˆS(N((R!RÃ(t pivot_inv(s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRÝ: RÞc st|ˆˆ|fˆƒS(N(R>(R!R(RyRqRw(s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRÝB RÞ(R™RœtrowstcolsR†t inv_quickR›RÿRlR>RûR<ReRfRˆRjRR‡trowtrow_delR¯tcol_swapR R„trow_op(RžRnRºt do_simplifyR4RRcRdRzRLtnrowstrowitipRtrowjRÃtjpt solutionstcontent((RyRqRwR¦s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRp´s¦(,")          &$$ c s“t|tƒr"|j|j}nt|ƒjƒd}tt|jƒˆdt ƒj ƒƒ}t ‡fd†|Dƒƒs‹t |||ŽSdSdS(s#Solve equation of a type p(x; a_1, ..., a_k) == q(x) where both p, q are univariate polynomials and f depends on k parameters. The result of this functions is a dictionary with symbolic values of those parameters with respect to coefficients in q. This functions accepts both Equations class instances and ordinary SymPy expressions. Specification of parameters and variable is obligatory for efficiency and simplicity reason. >>> from sympy import Eq >>> from sympy.abc import a, b, c, x >>> from sympy.solvers import solve_undetermined_coeffs >>> solve_undetermined_coeffs(Eq(2*a*x + a+b, x), [a, b], x) {a: 1/2, b: -1/2} >>> solve_undetermined_coeffs(Eq(a*c*x + a+b, x), [a, b], x) {a: 1/c, b: -1/c} iRc3 s|]}|jˆƒVqdS(N(R³(Rbtequ(RE(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ˜ sN(RhR RóRŸRMR°RfR?RRšR<RˆRRj(R¶tcoeffsRERºRž((REs4lib/python2.7/site-packages/sympy/solvers/solvers.pyR6z s'cC sµ|j|jdkr%tdƒ‚n|d|j…d|j…f}|dd…|jdd…f}|j|ƒ}i}x/t|jƒD]}||df|||>> from sympy import Matrix >>> from sympy.abc import x, y, z >>> from sympy.solvers.solvers import solve_linear_system_LU >>> solve_linear_system_LU(Matrix([ ... [1, 2, 0, 1], ... [3, 2, 2, 1], ... [2, 0, 0, 1]]), [x, y, z]) {x: 1/2, y: 1/4, z: -1/2} See Also ======== sympy.matrices.LUsolve is#Rows should be equal to columns - 1Ni(R§R¨RetLUsolveR(RwRztAR%R1R´Rq((s4lib/python2.7/site-packages/sympy/solvers/solvers.pytsolve_linear_system_LU¡ s"#c C sÒg}t}|j}t|ddƒ}|dkrHt|jƒƒ}nx}t|ƒD]o}g}d}x-|D]%}|j|||ƒ||7}qnWt|Œ} |j|rµ| n| ƒ| }qUWt |ŒS(sFReturn the det(``M``) by using permutations to select factors. For size larger than 8 the number of permutations becomes prohibitively large, or if there are no symbols in the matrix, it is better to use the standard determinant routines, e.g. `M.det()`. See Also ======== det_minor det_quick t_matiN( RœR§RiRjRZttolistRYRkRR ( tMR£RrR¶tlist_tpermtfactidxRtterm((s4lib/python2.7/site-packages/sympy/solvers/solvers.pytdet_permÆ s      c C sÃ|j}|dkr5|d|d|d|d Stgt|ƒD]s}|d|fr¯d |dtgtjt|jd|ƒƒƒD]}|d|f|^q‹Œntj^qEƒSdS( s–Return the ``det(M)`` computed from minors without introducing new nesting in products. See Also ======== det_perm det_quick iiiiÿÿÿÿN(ii(ii(ii(ii(iiÿÿÿÿ( R§R;RR R…t det_minortminor_submatrixR Rú(R½R¶RqR((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRÄã s   cC sstd„|DƒƒrO|jdkrEtd„|DƒƒrEt|ƒSt|ƒS|re|jd|ƒS|jƒSdS(sReturn ``det(M)`` assuming that either there are lots of zeros or the size of the matrix is small. If this assumption is not met, then the normal Matrix.det function will be used with method = ``method``. See Also ======== det_minor det_perm cs s|]}|jtƒVqdS(N(R³R (RbRq((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys sics s|]}|jtƒVqdS(N(R³R (RbRq((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys  stmethodN(RˆR§RûRÃRÄtdet(R½RÆ((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt det_quickõ s %  c C sddlm}td„|DƒƒsTtd„|DƒƒsHd„}q^d„}n |jƒS|j}||ƒ}|tjkr‘tdƒ‚n||ƒ}d}xmt |ƒD]_}| }}xKt |ƒD]=} ||j || ƒƒ} || ||| |f<| }qÎWq°W|S(szReturn the inverse of ``M``, assuming that either there are lots of zeros or the size of the matrix is small. iÿÿÿÿ(RKcs s|]}|jVqdS(N(R{(RbRq((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys  scs s|]}|jVqdS(N(R{(RbRq((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys  scS s t|ƒS(N(RÃ(RÃ((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRÝ RÞcS s t|ƒS(N(RÄ(RÃ((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRÝ RÞs Matrix det == 0; not invertible.( tsympy.matricesRKRûRˆR4R§R RúReRRÅ( R½RKRÇR¶Rtretts1RqRrRRˆ((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyR© s&       cC st|ƒtjt|ƒfS(N(R4R tPi(R!((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRÝ& RÞcC s!t|ƒdtjt|ƒfS(Ni(R3R RÌ(R!((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRÝ' RÞc( s´ d|krg|d| ƒD]L\} }t|ƒ}!|!|kr“ ˆjˆ|!ƒj?dƒr“ |!| | >> from sympy import log >>> from sympy.solvers.solvers import _tsolve as tsolve >>> from sympy.abc import x >>> tsolve(3**(2*x + 5) - 4, x) [-5/2 + log(2)/log(3), (-5*log(3)/2 + log(2) + I*pi)/log(3)] >>> tsolve(log(x) + 2*x, x) [LambertW(2)/2] t tsolve_sawR•iics s|]}|jVqdS(N(tis_Dummy(RbR)((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys i scS s%|j|ƒp$t|ƒt|ƒkS(N(tequalsRC(texpr1texpr2((s4lib/python2.7/site-packages/sympy/solvers/solvers.pytequal‚ scs s!|]}|dkr|VqdS(iN((RbRq((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ¡ sc3 s0|]&}ˆjˆ|ƒjdƒr|VqdS(iN(RaRÏ(RbRr(R‰RE(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ³ st bivariatetdeepiN(CRjRkRkRRNRBRRRER™RœtcountR-RhR£R.R@RvR±R‡R}RˆRöRaR³R"RCRµR>RARGRRùRfRRyR´RR‹R(R#R"t is_irrationalR°RFt is_positiveRR²R†Rtmulti_inversesR/R¤Rðt_filtered_gensRlR~RRŠR›Rÿt_solve_lambertRgRÏtbivariate_typeRšRl((R‰RERºRŸRóRtsol_baseRrR¹RÒte_ratR¶RtlogformR½RwR)Rtb_lte_lR%RqtllhsR1R¤RSt up_or_logtgitgisimptdownteq_downRQRFtnstgpuR‹R]t inversiontposRÄ((R‰REs4lib/python2.7/site-packages/sympy/solvers/solvers.pyR@+ s,     !  " 2#&8 +!7#    # &  . 29/  ((     +   '     :    0 cO sd|kr!ttdƒƒ‚nd|krW|jdƒ}ddl}||j_nd}|jdtƒ}t|ƒdkrú|d}|d }|d }t |ƒr…t |ƒr…t|ƒt|ƒkr÷t d t|ƒt|ƒfƒ‚q÷q…n‹t|ƒd krD|d}d}|d }t |ƒr…t d ƒ‚q…nAt|ƒd krot d t|ƒƒ‚nt dt|ƒƒ‚|j ddgƒ}t |ƒrt |ƒ}x@t |ƒD]2\} } t| tƒr¿| j| j|| >> from sympy import Symbol, nsolve >>> import sympy >>> import mpmath >>> mpmath.mp.dps = 15 >>> x1 = Symbol('x1') >>> x2 = Symbol('x2') >>> f1 = 3 * x1**2 - 2 * x2**2 - 1 >>> f2 = x1**2 - 2 * x1 + x2**2 + 2 * x2 - 8 >>> print(nsolve((f1, f2), (x1, x2), (-1, 1))) Matrix([[-1.19287309935246], [1.27844411169911]]) For one-dimensional functions the syntax is simplified: >>> from sympy import sin, nsolve >>> from sympy.abc import x >>> nsolve(sin(x), x, 2) 3.14159265358979 >>> nsolve(sin(x), 2) 3.14159265358979 To solve with higher precision than the default, use the prec argument. >>> from sympy import cos >>> nsolve(cos(x) - x, 1) 0.739085133215161 >>> nsolve(cos(x) - x, 1, prec=50) 0.73908513321516064165531208767387340401341175890076 >>> cos(_) 0.73908513321516064165531208767387340401341175890076 To solve for complex roots of real functions, a nonreal initial point must be specified: >>> from sympy import I >>> nsolve(x**2 + 2, I) 1.4142135623731*I mpmath.findroot is used and you can find there more extensive documentation, especially concerning keyword parameters and available solvers. Note, however, that functions which are very steep near the root the verification of the solution may fail. In this case you should use the flag `verify=False` and independently verify the solution. >>> from sympy import cos, cosh >>> from sympy.abc import i >>> f = cos(x)*cosh(x) - 1 >>> nsolve(f, 3.14*100) Traceback (most recent call last): ... ValueError: Could not find root within given tolerance. (1.39267e+230 > 2.1684e-19) >>> ans = nsolve(f, 3.14*100, verify=False); ans 312.588469032184 >>> f.subs(x, ans).n(2) 2.1e+121 >>> (f/f.diff(x)).subs(x, ans).n(2) 7.4e-15 One might safely skip the verification if bounds of the root are known and a bisection method is used: >>> bounds = lambda i: (3.14*i, 3.14*(i + 1)) >>> nsolve(f, bounds(100), solver='bisect', verify=False) 315.730061685774 Alternatively, a function may be better behaved when the denominator is ignored. Since this is not always the case, however, the decision of what function to use is left to the discretion of the user. >>> eq = x**2/(1 - x)/(1 - 2*x)**2 - 100 >>> nsolve(eq, 0.46) Traceback (most recent call last): ... ValueError: Could not find root within given tolerance. (10000 > 2.1684e-19) Try another starting point or tweak arguments. >>> nsolve(eq.as_numer_denom()[0], 0.46) 0.46792545969349058 RÆsò Keyword "method" should not be used in this context. When using some mpmath solvers directly, the keyword "method" is used, but when using nsolve (and findroot) the keyword to use is "solver".tpreciÿÿÿÿNR›iiiis0nsolve expected exactly %i guess vectors, got %is"nsolve expected 3 arguments, got 2s,nsolve expected at least 2 arguments, got %is+nsolve expected at most 3 arguments, got %itmodulestmpmathsB expected a one-dimensional and numerical functions9 need at least as many equations as variablestverbosesf(x):sJ(x):tJ(ReRWRðRítmptdpsRjRšR†RRÑR™RfRgRhR RóRŸRJRR‡RrRVRR\R¨RötprinttjacobianR›Rÿ(R£tkwargsRëRíRRtfargstx0RìRqR¼RzR!RîRïR3((s4lib/python2.7/site-packages/sympy/solvers/solvers.pytnsolve sˆl      %        .    /cO s t|ƒ}|jr*|j|jŒ}n|j}|sB|}n|t|ƒ@s_|tjfSt|jdt ƒƒ}|}tj}xxt r|}xqt r|j |Œ\}} |j râ|tjkrÏPn| }||8}q˜|tj krõPn| }||}q˜W|j rìi} x?|jD]4} | j |Œ\} } | j| gƒj| ƒq"Wtd„| jƒDƒƒrìg}x[| jƒD]M\} } t| ƒdkrÁ|jt| Œ| ƒq‰|j| d| ƒq‰Wt|Œ}qìn|j rÆ| rÆt|jƒdkrÆ|j|Œ rÆt|jƒ\} }| j |Œ\}}|j |Œ\}}td„||fDƒƒr |jƒ\}}|jƒ\}}||krÐtt||ƒƒ}| |}qÃ||}t||ƒ}||krÃ|}| |}qÃqý|| krýt|tƒrÃ|j|jkrÃt|jƒt|jƒkoddknr„|jd|jd}qÀt|jƒt|jƒkr±tdƒ‚qÀtdƒ‚qÃqýn7|jrýtd „|jDƒƒrýtt|ƒƒ}n|jr3t |d ƒrLt|jƒdkrL|j!ƒ|ƒ}|jd}q3t|t"ƒr—|j\}}dt#|t$|d|dƒ|ƒ}q3|j|jkr3t|jƒt|jƒkoÒdknrô|jd}|jd}q0t|jƒt|jƒkr!tdƒ‚q0tdƒ‚q3n|rt|j%rt|j&j'rt|j&dkrtd|}d|}n|j%rí|j&j'r|sÐ|j&j' rít|ƒdkrít|j(jt|ƒ@ƒdkrí|d|j&}|j(}n||kr‰Pq‰q‰W||fS( sReturn tuple (i, d) where ``i`` is independent of ``symbols`` and ``d`` contains symbols. ``i`` and ``d`` are obtained after recursively using algebraic inversion until an uninvertible ``d`` remains. If there are no free symbols then ``d`` will be zero. Some (but not necessarily all) solutions to the expression ``i - d`` will be related to the solutions of the original expression. Examples ======== >>> from sympy.solvers.solvers import _invert as invert >>> from sympy import sqrt, cos >>> from sympy.abc import x, y >>> invert(x - 3) (3, x) >>> invert(3) (3, 0) >>> invert(2*cos(x) - 1) (1/2, cos(x)) >>> invert(sqrt(x) - 3) (3, sqrt(x)) >>> invert(sqrt(x) + y, x) (-y, sqrt(x)) >>> invert(sqrt(x) + y, y) (-sqrt(x), y) >>> invert(sqrt(x) + y, x, y) (0, sqrt(x) + y) If there is more than one symbol in a power's base and the exponent is not an Integer, then the principal root will be used for the inversion: >>> invert(sqrt(x + y) - 2) (4, x + y) >>> invert(sqrt(x + y) - 2) (4, x + y) If the exponent is an integer, setting ``integer_power`` to True will force the principal root to be selected: >>> invert(x**2 - 4, integer_power=True) (2, x) t integer_powercs s!|]}t|ƒdkVqdS(iN(R†(RbRd((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys 0 siiics s|]}t|ƒVqdS(N(Rx(RbRq((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys @ ss(equal function with more than 1 arguments'function with different numbers of argscs s|]}t|ƒVqdS(N(Rx(RbRå((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys Z stinverse()RR£RR‡RyR RúR¥R™RšRœR¬RR„t setdefaultRkRˆR<RlR†R t is_polynomialRR"R@RBRhRRöReRR²thasattrRùR;R5R:RvR.R±R}(R‰RnRôRƒtdointpowRóRŸRÀtindepRDRmRåRqRR£R%taitadtbitbdta_baseta_exptb_basetb_exptratt_lhstyR!((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyRkØ s´-           %    !. " $-.  *  4  cG  s|d}tdtdtƒ‰‡‡fd†}‡fd†}d„‰‡‡fd†‰|jdˆƒ‰gttd gd td d ƒjƒƒD]\}}|j||ƒ^q‘\‰}} tt|d tdtƒƒ}|j ƒ\}} t |dtƒ}|j rdSnt ˆƒp"|j ‰|jƒ} g| jD]} ˆ| tƒrV| ^q;} | rjdSnt‡fd†| DƒƒrdSnt‡fd†| Dƒƒr°dSn‡‡fd†}|| ƒ\}}}| rådSntddtƒ}t ƒ}x"|D]}|jˆ|j @ƒqW|ˆkr`|‰g| D]} | j ˆ@rW| ^q>} nttt|ttt|ƒƒƒƒƒƒ}igf6‰tj| jƒƒ}x†|D]~}ˆ|tƒrt |jƒjƒj|ƒ}ttg|D]}||^qöƒƒ}nf}ˆj|gƒj|ƒq¶WtˆjfƒŒ}gˆjƒD]}tˆ|Œ^qZ‰tt tt!ˆƒƒƒƒ‰t}t"|ƒ}tˆƒdkoψd j#oÎ|dk ròˆd || |}t}n¢ tˆƒdkoˆd j#r'tˆd j$ƒ‰nt|ƒdkr<|jƒ}tˆƒdkr“|j }d„| Dƒ|@} | r„|} nt!| ƒ} nˆ} t| ƒd } y|t%|||| ˆ}!|! rÖt&‚n| jƒj'|||ƒj'| |!d ƒ}|||||ƒ||ˆƒSWnt&k r8nXn+g| D]} ˆ| ƒdkra| ^qC} tˆƒdkr¾| r¤ˆd |ˆd |}t}nt(|dƒj) r»ˆ\}"}#|j*dtƒrê|"|#f\}#}"n||"jƒƒ}$\}%}&}'||#jƒƒ}(\})}*}+xtdƒD]},|,rh|(|$f\}$}(|#|"f\}"}#n|(\})}-}+t+|)Œ})|)|+}.||+|.}/x ˆD]} yÕt%|/| ˆ}0|0 rÍt&‚n|"j'| |0d ƒ||#|)|}1t,|1|ƒ}2|2rb|2\}}3|3rR|3\}4}5||4|/j'|t%|5|ˆd ƒƒn |||/ƒn|1}|||/ƒt}PWn&t&k r¥|,r¢t&dƒ‚nnXq¢W|r´Pnq5Wnn¶tˆƒdkrtgˆD]}||jƒƒ^q׉d ‰d‰d}6ˆd |6dkrJˆjˆjd ƒƒˆjˆjd ƒƒnCˆd|6dkrˆjˆjdƒƒˆjˆjdƒƒnˆd |6ˆd|6ko´dknrqˆdˆˆdˆkr ˆdˆd f\ˆd <ˆd<ˆdˆd f\ˆd <ˆd}?ˆd }@|}A|:j-tt|7|8||9|/| f|<|=|>|?|@|Afƒƒƒ}t}nnn| r”t(|dƒj)oµ| o£tˆƒd$kpµtˆƒd$kr‘d,„}Btˆƒd$kr ˆ\}"}#}C}D|B|"|#ƒ|B|C|Dƒ}t}n„tˆƒdkrPˆ\}"}#}C|B|#|Cƒ|B|"|ƒ}t}n>tˆƒdkrŽˆ\}"}#|"d|B|#|ƒ}t}nnn|r¦t"|ƒn|}E| d7} | pü|tk oütˆƒ|koü|Etk oü|E|koü| dkrt&d-ƒ‚n|jtd ˆd tˆƒd | ƒƒt,|ˆ|Ž}F|Fr]|F\}‰n||ˆƒ\}‰|ˆfS(.sá Remove radicals with symbolic arguments and return (eq, cov), None or raise an error: None is returned if there are no radicals to remove. NotImplementedError is raised if there are radicals and they cannot be removed or if the relationship between the original symbols and the change of variable needed to rewrite the system as a polynomial cannot be solved. Otherwise the tuple, ``(eq, cov)``, is returned where:: ``eq``, ``cov`` ``eq`` is an equation without radicals (in the symbol(s) of interest) whose solutions are a superset of the solutions to the original expression. ``eq`` might be re-written in terms of a new variable; the relationship to the original variables is given by ``cov`` which is a list containing ``v`` and ``v**p - b`` where ``p`` is the power needed to clear the radical and ``b`` is the radical now expressed as a polynomial in the symbols of interest. For example, for sqrt(2 - x) the tuple would be ``(c, c**2 - 2 + x)``. The solutions of ``eq`` will contain solutions to the original equation (if there are any). ``syms`` an iterable of symbols which, if provided, will limit the focus of radical removal: only radicals with one or more of the symbols of interest will be cleared. All free symbols are used if ``syms`` is not set. ``flags`` are used internally for communication during recursive calls. Two options are also recognized:: ``take``, when defined, is interpreted as a single-argument function that returns True if a given Pow should be handled. Radicals can be removed from an expression if:: * all bases of the radicals are the same; a change of variables is done in this case. * if all radicals appear in one term of the expression * there are only 4 terms with sqrt() factors or there are less than four terms having sqrt() factors * there are only two terms with radicals Examples ======== >>> from sympy.solvers.solvers import unrad >>> from sympy.abc import x >>> from sympy import sqrt, Rational, root, real_roots, solve >>> unrad(sqrt(x)*x**Rational(1, 3) + 2) (x**5 - 64, []) >>> unrad(sqrt(x) + root(x + 1, 3)) (x**3 - x**2 - 2*x - 1, []) >>> eq = sqrt(x) + root(x, 3) - 2 >>> unrad(eq) (_p**3 + _p**2 - 2, [_p, _p**6 - x]) s3cannot get an analytical solution for the inversionR½R>c svˆreˆ\}}t||ƒj|ƒdkr\||j|t||ˆdƒgˆ(qrt‚n ||gˆ(dS(Niii(ii(RORQRaRRö(R‹Rwtoldptolde(Ratuflags(s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt_covÒ s  , c sf|rX|\}}it|jƒ|6}|j|ƒ}|j|ƒ|j|ƒg}ntt|jƒddtƒdtƒ}|jrùg}xX|jD]M}|j r®q™n|j rÙˆ|tƒrÙ|j |j ƒq™|j |ƒq™Wt |Œ}n|j}t|ƒdkrF|j|jƒt|ƒƒjƒr\| }q\n|jƒr\| }n||fS(NiR”tcleari(R tnameRþRRR°RœRR£R­RvRkR}RR‡R†RyRðRQtcould_extract_minus_sign(R‰RaR‹RwtrepR£RRƒ(t_take(s4lib/python2.7/site-packages/sympy/solvers/solvers.pyR%Ý s, !(   %   cS s1|jƒdjƒd}|js*tjS|jS(Nii(R"R$R´R R„R#(tpowR&((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt_Qý s c s˜x‘tj|ƒD]€}|jp%|js.qn|jƒ\}}|jˆŒsUqn| rtˆ|ƒdkrtqn|j}|jˆƒrtSqWt S(Ni( RR…RôRvR"R³R‡R:RœRš(Rt take_int_powRR%RwRƒ(RRz(s4lib/python2.7/site-packages/sympy/solvers/solvers.pyR s RRaR¶trptitradicalRR”Nc3 s!|]}ˆ|ƒdkVqdS(iN((RbRS(R(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys ' sc3 s(|]}|jƒdjˆŒVqdS(iN(R"R³(RbRS(Rz(s4lib/python2.7/site-packages/sympy/solvers/solvers.pys * sc s•d}tƒ}tƒ}xm|jD]b}ˆ|tƒs=q"nˆ|ƒ}|dkr"|j|ƒt||ƒ}|j|jƒq"q"W|||fS(Ni(RyR9RšR~R R}(RQtlcmtradsRTRSR#(RR(s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt_rads_bases_lcm- s     R‹t nonnegativeiicS sh|]}|jr|’qS((Rô(RbRS((s4lib/python2.7/site-packages/sympy/solvers/solvers.pys l s t_reverses&no successful change of variable foundiitabcdABi iii?ii-ii<ii$iiTi~c s:tˆ|ˆŒ}tˆ||ƒtˆ|ˆŒfS(N(RRM(RqR%(tBASEStRADtinfotrterms(s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt_t× scS s|d|dd||S(Ni((RåR%((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt_norm2æ ssCannot remove all radicals(.R›RšRúRRjRlRBRRœR°RR­RyR‡RlR9RûRˆR R8RfRÿRR†R R…RžR:RìRkRðR§R¢RRHRR£RRöRaR-R±R™RR?Rþ(GR‰RzRºt _inv_errorR R%RcRdtnwasRRRQRSR9RRRTRtcovsymtnewsymsRtdradR£R)tcommonRqRÌtothersRtdepthR%RƒR!R4tr0R|ti0t_rads0t_bases0tlcm0ti1t_rads1t_bases1tlcm1treverseRÃtt1R&R¹tneweqttmptnewcovtnewptnewctLCMRåR¹R¾tzzR"taatAAtbbtBBtcctddR#tr2tr3t new_depthtneq(( RRRRRaR R!RzR s4lib/python2.7/site-packages/sympy/solvers/solvers.pyR? sj>  R  +   )-  ,) ,     , +           %,"%& 1 ÿÿÿÿ'  !$      ((RÛRÚRÙ( t__doc__t __future__RRtsympyRtsympy.core.compatibilityRRRRRtsympy.core.sympifyRt sympy.coreR R R R R RRRRtsympy.core.exprtoolsRtsympy.core.functionRRRRRRRRRRRRtsympy.integrals.integralsRtsympy.core.numbersR R!R"tsympy.core.relationalR#R$R%tsympy.core.logicR&R'tsympy.core.powerR(tsympy.logic.boolalgR)R*R+tsympy.core.basicR,tsympy.functionsR-R.R/R0R1R2R3R4R5R6R7R8R9R:R;t(sympy.functions.elementary.trigonometricR<R=tsympy.simplifyR>R?R@RARBRCRDRERFRGtsympy.simplify.sqrtdenestRHtsympy.simplify.fuRIRÉRJRKt sympy.polysRLRMRNRORPRQtsympy.polys.polyerrorsRRRSt$sympy.functions.elementary.piecewiseRTRUtsympy.utilities.lambdifyRVR›RWRqRXRYRZtsympy.utilities.decoratorR[RíR\tsympy.solvers.polysysR]tsympy.solvers.inequalitiesR^ttypesR_t collectionsR`R·RuRxR‚RzRjRRÎRÕRRRR7RoRpR6RºRÃRÄRÈR©RØR@R÷RkR?tsympy.solvers.bivariateRÛRÚRÙ(((s4lib/python2.7/site-packages/sympy/solvers/solvers.pyt s‚(@RdF.  )   4 ¿  7 ÿÿÿŒ ÿ— É· P Æ ' %       æÇ ¸ ÿy