\h4SrSSKJr SSKJr SSKJr SSKJrJ r SSK J r SSK J r Jr SSK Jr SS KJr SS KJr SS KJr "S S \5r"SS\ 5rSrSrSSjrSrSrg)z!Low-level linear systems solver. )sympy_deprecation_warning)connected_components)sympify)IntegerRational)MutableDenseMatrix)ZZQQ)EX)sring) NotInvertible) DomainMatrixc\rSrSrSrSrg)PolyNonlinearErrorz/Raised by solve_lin_sys for nonlinear equationsN)__name__ __module__ __qualname____firstlineno____doc____static_attributes__rK/var/www/auris/envauris/lib/python3.13/site-packages/sympy/polys/solvers.pyrrs9rrc0\rSrSrSr\"S5rSrSrg) RawMatrixaa .. deprecated:: 1.9 This class fundamentally is broken by design. Use ``DomainMatrix`` if you want a matrix over the polys domains or ``Matrix`` for a matrix with ``Expr`` elements. The ``RawMatrix`` class will be removed/broken in future in order to reestablish the invariant that the elements of a Matrix should be of type ``Expr``. cU$Nr)xargskwargss rRawMatrix."sqrc[SSSS9 [n[UR5GH:n[UR5GHnXU4n[ USS5(a*UR URnUR5nO[US5(a"UR5nURU5nO[U[[45(a[n[U5nO`[U[ 5(a ["nUnOB[["4H,nUR%U5(dMURU5n O [&eUR)U5nXXE4'GM GM= X0lg)Nzs The RawMatrix class is deprecated. Use either DomainMatrix or Matrix instead. z1.9zdeprecated-rawmatrix)deprecated_since_versionactive_deprecations_targetis_PolyFparent)rr rangerowscolsgetattrdomaingensas_exprhasattrr)to_sympy isinstanceintrrrr of_type TypeErrorunifyring) selfr!r"r.ijvalK val_sympys r__init__RawMatrix.__init__$s%! &+'=  tyy!A499%Q3i3 511 388,A # IS(++ A ! 3Ic7^44A ' IX..A #IV99S>>() 3I!$ (a%QS -&"0 r)r8N) rrrrr staticmethod_sympifyr?rrrrrrs 89H#rrc[U5VVs0sHupEXT_M nnn[U5n[U5S-n[U5V s/sHoR/U-PM n n [ XU5HJupn U R 5HupUR U5XU'M UR U 5*U S'ML [XU4U5$s snnfs sn f)aGet matrix from linear equations in dict format. Explanation =========== Get the matrix representation of a system of linear equations represented as dicts with low-level DomainElement coefficients. This is an *internal* function that is used by solve_lin_sys. Parameters ========== eqs_coeffs: list[dict[Symbol, DomainElement]] The left hand sides of the equations as dicts mapping from symbols to coefficients where the coefficients are instances of DomainElement. eqs_rhs: list[DomainElements] The right hand sides of the equations as instances of DomainElement. gens: list[Symbol] The unknowns in the system of equations. domain: Domain The domain for coefficients of both lhs and rhs. Returns ======= The augmented matrix representation of the system as a DomainMatrix. Examples ======== >>> from sympy import symbols, ZZ >>> from sympy.polys.solvers import eqs_to_matrix >>> x, y = symbols('x, y') >>> eqs_coeff = [{x:ZZ(1), y:ZZ(1)}, {x:ZZ(1), y:ZZ(-1)}] >>> eqs_rhs = [ZZ(0), ZZ(-1)] >>> eqs_to_matrix(eqs_coeff, eqs_rhs, [x, y], ZZ) DomainMatrix([[1, 1, 0], [1, -1, 1]], (2, 3), ZZ) See also ======== solve_lin_sys: Uses :func:`~eqs_to_matrix` internally ) enumeratelenr*zerozipitemsconvertr) eqs_coeffseqs_rhsr/r.nr sym2indexnrowsncols_r+roweq_coeffeq_rhssymcoeffs r eqs_to_matrixrXJs\#,D/2/$!/I2  OE IME+0< 8>&))B"@ enf 553 9s C Cc[XSSS9up#X2R54$![a [X[S9up#N-f=f)asConvert a system of equations from Expr to a PolyRing Explanation =========== High-level functions like ``solve`` expect Expr as inputs but can use ``solve_lin_sys`` internally. This function converts equations from ``Expr`` to the low-level poly types used by the ``solve_lin_sys`` function. Parameters ========== eqs: List of Expr A list of equations as Expr instances symbols: List of Symbol A list of the symbols that are the unknowns in the system of equations. Returns ======= Tuple[List[PolyElement], Ring]: The equations as PolyElement instances and the ring of polynomials within which each equation is represented. Examples ======== >>> from sympy import symbols >>> from sympy.polys.solvers import sympy_eqs_to_ring >>> a, x, y = symbols('a, x, y') >>> eqs = [x-y, x+a*y] >>> eqs_ring, ring = sympy_eqs_to_ring(eqs, [x, y]) >>> eqs_ring [x - y, x + a*y] >>> type(eqs_ring[0]) >>> ring ZZ(a)[x,y] With the equations in this form they can be passed to ``solve_lin_sys``: >>> from sympy.polys.solvers import solve_lin_sys >>> solve_lin_sys(eqs_ring, ring) {y: 0, x: 0} T)field extension)r.)r r r to_domain)eqssymbolsr=eqs_Ks rsympy_eqs_to_ringr`sJ^2TTB ++-  2b152s ==c^U(+nTRR(deUVs/sHn[U5PM nnTRR 5SnTRR n/n/n UHn U R Xg5n 0n U R5HAup[U 5S:wa Sn[U5eXTRU RS5'MC U (d U (dM{ gURU 5 U RU 5 M [XT5nUbU(aU4SjnUR5VVs0sHunnU"U5U"U5_M nnn0nUR5H9unnUR(aUR5unnUU- UU'M4UUU'M; U$s snfs snnf)aSolve a system of linear equations from a PolynomialRing Explanation =========== Solves a system of linear equations given as PolyElement instances of a PolynomialRing. The basic arithmetic is carried out using instance of DomainElement which is more efficient than :class:`~sympy.core.expr.Expr` for the most common inputs. While this is a public function it is intended primarily for internal use so its interface is not necessarily convenient. Users are suggested to use the :func:`sympy.solvers.solveset.linsolve` function (which uses this function internally) instead. Parameters ========== eqs: list[PolyElement] The linear equations to be solved as elements of a PolynomialRing (assumed equal to zero). ring: PolynomialRing The polynomial ring from which eqs are drawn. The generators of this ring are the unknowns to be solved for and the domain of the ring is the domain of the coefficients of the system of equations. _raw: bool If *_raw* is False, the keys and values in the returned dictionary will be of type Expr (and the unit of the field will be removed from the keys) otherwise the low-level polys types will be returned, e.g. PolyElement: PythonRational. Returns ======= ``None`` if the system has no solution. dict[Symbol, Expr] if _raw=False dict[Symbol, DomainElement] if _raw=True. Examples ======== >>> from sympy import symbols >>> from sympy.polys.solvers import solve_lin_sys, sympy_eqs_to_ring >>> x, y = symbols('x, y') >>> eqs = [x - y, x + y - 2] >>> eqs_ring, ring = sympy_eqs_to_ring(eqs, [x, y]) >>> solve_lin_sys(eqs_ring, ring) {y: 1, x: 1} Passing ``_raw=False`` returns the same result except that the keys are ``Expr`` rather than low-level poly types. >>> solve_lin_sys(eqs_ring, ring, _raw=False) {x: 1, y: 1} See also ======== sympy_eqs_to_ring: prepares the inputs to ``solve_lin_sys``. linsolve: ``linsolve`` uses ``solve_lin_sys`` internally. sympy.solvers.solvers.solve: ``solve`` uses ``solve_lin_sys`` internally. rrDz+Nonlinear term encountered in solve_lin_sysNcp>[USS5nU(aU"5$TRRU5$)Nr0)r-r.r2)r r0r8s rr2solve_lin_sys..to_sympys1aD1Gy {{++A..r)r.is_FielddictonemonomsrHpoprJsumrr/indexappend_solve_lin_sysis_Mul as_coeff_Mul)r]r8_rawr0eqeqs_dict one_monomrHrMrLeq_dictrU eq_coeffsmonomrWmsgresultr2rVr<tresultkvcss ` r solve_lin_sysr}sBhG ;;   #&'3RR3H'!!$I ;;  DGJY- #MMOLE5zQC(--38dii A/ 0 , v)$ J 6F g /AG OHC8C=(3-/OMMODAqxx~~'1aCq q $ M[(DPs F< Gc XURn/nUH/n[U5nUR[USSUSS55 M1 X44n[ U5n0n [ U5HupU Hn XU 'M M [ [U55V s/sHn //4PM nn [X5HGunn[[U5S5n XU unnURU5 URU5 MI 0nUH,n[USUSU5nUc gURU5 M. U$s sn f)a Solve a linear system from dict of PolynomialRing coefficients Explanation =========== This is an **internal** function used by :func:`solve_lin_sys` after the equations have been preprocessed. The role of this function is to split the system into connected components and pass those to :func:`_solve_lin_sys_component`. Examples ======== Setup a system for $x-y=0$ and $x+y=2$ and solve: >>> from sympy import symbols, sring >>> from sympy.polys.solvers import _solve_lin_sys >>> x, y = symbols('x, y') >>> R, (xr, yr) = sring([x, y], [x, y]) >>> eqs = [{xr:R.one, yr:-R.one}, {xr:R.one, yr:R.one}] >>> eqs_rhs = [R.zero, -2*R.one] >>> _solve_lin_sys(eqs, eqs_rhs, R) {y: 1, x: 1} See also ======== solve_lin_sys: This function is used internally by :func:`solve_lin_sys`. NrErDr) r/listextendrIrrFr*rGnextiterrk_solve_lin_sys_componentupdate)rLrMr8VErtsymsG componentssym2comprN componentrVrR subsystemsrTrU sub_coeffsub_rhssol subsystemsubsols rrlrl0s9< A A I T#2YQR)*  A%a(JH!*- CSM.%*#j/$:;$:q2r($:J; 4&4>4(' 6 7"v 5 C ))A, ! dK > 6  J>> from sympy import symbols, sring >>> from sympy.polys.solvers import _solve_lin_sys_component >>> x, y = symbols('x, y') >>> R, (xr, yr) = sring([x, y], [x, y]) >>> eqs = [{xr:R.one, yr:-R.one}, {xr:R.one, yr:R.one}] >>> eqs_rhs = [R.zero, -2*R.one] >>> _solve_lin_sys_component(eqs, eqs_rhs, R) {y: 1, x: 1} See also ======== solve_lin_sys: This function is used internally by :func:`solve_lin_sys`. rENr8c3^># UH"nTTU(dMTTUTU-v M$ g7frr).0r;echelongr:s r +_solve_lin_sys_component..s6$eASAW^_`WabcWd%7WQZ]1Q4%7ASs--rD)rXr/r.rdto_fieldrrefrGrepto_ddmrkrerIr1r8 ground_newrFrir*)rLrMr8matrixpivotskeysrrSr|asolsrKrzvals_setvals_mapeieijprrr:s @@@rrrmsB: 4;; GF == ! !"kkmOGV 99D &*D ) 6{c$i%,[[%7%7%9:%9cb'%9:AA JJqM;CN#" K II 4 ii**GooG++$$&!(6##QA#A6+348awqzM84;BC7RR0RcHSMR07Cf%DAq 2$eqsCPQFAS$e!eeAaM& K);740Cs*?H !H<H H!H -H!H!N)T)rsympy.utilities.exceptionsrsympy.utilities.iterablesrsympy.core.sympifyrsympy.core.numbersrrsympy.matrices.densersympy.polys.domainsr r r sympy.polys.ringsr sympy.polys.polyerrorsr sympy.polys.domainmatrixr ExceptionrrrXr`r}rlrrrrrsb'A:&03&"#01  0"0f76t4 nrj:zFr