o o hZ@sdZddlmZddlmZddlmZmZmZm Z ddl m Z m Z ddl mZe dZe d ed Zd5ddZd6ddZd6ddZd7ddZd8ddZd8ddZd9d!d"Zd:d$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4S);a" Module for the ddm_* routines for operating on a matrix in list of lists matrix representation. These routines are used internally by the DDM class which also provides a friendlier interface for them. The idea here is to implement core matrix routines in a way that can be applied to any simple list representation without the need to use any particular matrix class. For example we can compute the RREF of a matrix like: >>> from sympy.polys.matrices.dense import ddm_irref >>> M = [[1, 2, 3], [4, 5, 6]] >>> pivots = ddm_irref(M) >>> M [[1.0, 0.0, -1.0], [0, 1.0, 2.0]] These are lower-level routines that work mostly in place.The routines at this level should not need to know what the domain of the elements is but should ideally document what operations they will use and what functions they need to be provided with. The next-level up is the DDM class which uses these routines but wraps them up with an interface that handles copying etc and keeps track of the Domain of the elements of the matrix: >>> from sympy.polys.domains import QQ >>> from sympy.polys.matrices.ddm import DDM >>> M = DDM([[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]], (2, 3), QQ) >>> M [[1, 2, 3], [4, 5, 6]] >>> Mrref, pivots = M.rref() >>> Mrref [[1, 0, -1], [0, 1, 2]] ) annotations)mul) DMShapeError DMDomainErrorDMNonInvertibleMatrixErrorDMNonSquareMatrixError)SequenceTypeVar) RingElementTR)boundmatrixSequence[Sequence[T]]return list[list[T]]cCstttt|S)zmatrix transpose)listmapzip)rrn/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/polys/matrices/dense.py ddm_transpose8sra list[list[R]]bSequence[Sequence[R]]NonecCs:t||D]\}}t|D] \}}|||7<q qdS)za += bNr enumeraterraibijbijrrrddm_iadd= r%cCs:t||D]\}}t|D] \}}|||8<q qdS)za -= bNrr rrrddm_isubDr&r'cCs*|D]}t|D] \}}| ||<qqdS)za <-- -aNr)rr!r#aijrrrddm_inegKs  r*cCs,|D]}t|D] \}}||||<qqdS)z a <-- a*bNr(rrr!r#r)rrrddm_imulR r,cCs,|D]}t|D] \}}||||<qqdS)z a <-- b*aNr(r+rrr ddm_irmulYr-r.ccCsPtt|}t||D]\}}t|D]\}}ttt||||||<qq dS)z a += b @ cN)rrrsumrr)rrr/cTr"r!r#cTjrrr ddm_imatmul`s r3Fc s|t}|sgStd}d}g}t|D]|r5tt||fddd}|||<|<|}|s_t|d|D]}|}|r]|||<|<nqDq|}|d} t|D] } || | 9<qltD]/\} } | |ks| sq{| } | | 8<td|D]} | | | || 8<qq{||d7}||kr|Sq|S)aIn-place reduced row echelon form of a matrix. Compute the reduced row echelon form of $a$. Modifies $a$ in place and returns a list of the pivot columns. Uses naive Gauss-Jordan elimination in the ground domain which must be a field. This routine is only really suitable for use with simple field domains like :ref:`GF(p)`, :ref:`QQ` and :ref:`QQ(a)` although even for :ref:`QQ` with larger matrices it is possibly more efficient to use fraction free approaches. This method is not suitable for use with rational function fields (:ref:`K(x)`) because the elements will blowup leading to costly gcd operations. In this case clearing denominators and using fraction free approaches is likely to be more efficient. For inexact numeric domains like :ref:`RR` and :ref:`CC` pass ``_partial_pivot=True`` to use partial pivoting to control rounding errors. Examples ======== >>> from sympy.polys.matrices.dense import ddm_irref >>> from sympy import QQ >>> M = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]] >>> pivots = ddm_irref(M) >>> M [[1, 0, -1], [0, 1, 2]] >>> pivots [0, 1] See Also ======== sympy.polys.matrices.domainmatrix.DomainMatrix.rref Higher level interface to this routine. ddm_irref_den The fraction free version of this routine. sdm_irref A sparse version of this routine. References ========== .. [1] https://en.wikipedia.org/wiki/Row_echelon_form#Reduced_row_echelon_form rcst|SN)abs)iprr#rrszddm_irref..)keyr)lenrangemaxrappend)r_partial_pivotmnipivotsr6r)r!aijinvlkakakjrr7r ddm_irrefksLI     rIcCs t|}|s |jgfSt|d}d}g}g}d}t|D]}|||} | sNt|d|D]} || |} | rG|| ||||<|| <nq.||q|rs| |d|d} |durd|| |} t|D] \} } | || | <qh|D]%} t|D]} || | }|r|| 9}|dur|||}||| | <q{qut|D]6\} }| |krqt|d|D] }| |||||||}|dur|||}|||<q|j||<q|||d7}||krn || s| }qd}q|s|j}||fS|d|d}||fS)a#a <-- rref(a); return (den, pivots) Compute the fraction-free reduced row echelon form (RREF) of $a$. Modifies $a$ in place and returns a tuple containing the denominator of the RREF and a list of the pivot columns. Explanation =========== The algorithm used is the fraction-free version of Gauss-Jordan elimination described as FFGJ in [1]_. Here it is modified to handle zero or missing pivots and to avoid redundant arithmetic. The domain $K$ must support exact division (``K.exquo``) but does not need to be a field. This method is suitable for most exact rings and fields like :ref:`ZZ`, :ref:`QQ` and :ref:`QQ(a)`. In the case of :ref:`QQ` or :ref:`K(x)` it might be more efficient to clear denominators and use :ref:`ZZ` or :ref:`K[x]` instead. For inexact domains like :ref:`RR` and :ref:`CC` use ``ddm_irref`` instead. Examples ======== >>> from sympy.polys.matrices.dense import ddm_irref_den >>> from sympy import ZZ, Matrix >>> M = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(4), ZZ(5), ZZ(6)]] >>> den, pivots = ddm_irref_den(M, ZZ) >>> M [[-3, 0, 3], [0, -3, -6]] >>> den -3 >>> pivots [0, 1] >>> Matrix(M).rref()[0] Matrix([ [1, 0, -1], [0, 1, 2]]) See Also ======== ddm_irref A version of this routine that uses field division. sdm_irref A sparse version of :func:`ddm_irref`. sdm_rref_den A sparse version of :func:`ddm_irref_den`. sympy.polys.matrices.domainmatrix.DomainMatrix.rref_den Higher level interface. References ========== .. [1] Fraction-free algorithms for linear and polynomial equations. George C. Nakos , Peter R. Turner , Robert M. Williams. https://dl.acm.org/doi/10.1145/271130.271133 rNr)r;oner<r>exquorzerois_one)rKr@rAdrC no_pivotsrBr#r)r6 pivot_valjpjnpaijpajkpajkdenomrrr ddm_irref_denspW                  rYc Cs*t|}|s |jSt|d}|j}|j}t|dD]q}|||sJt|d|D]}|||rD||||||<||<| }nq*|jS|rV||d|dn|j}t|d|D]+}t|d|D]!} |||| ||||||||| |||| <qiq`q||ddS)aa <-- echelon(a); return det Explanation =========== Compute the determinant of $a$ using the Bareiss fraction-free algorithm. The matrix $a$ is modified in place. Its diagonal elements are the determinants of the leading principal minors. The determinant of $a$ is returned. The domain $K$ must support exact division (``K.exquo``). This method is suitable for most exact rings and fields like :ref:`ZZ`, :ref:`QQ` and :ref:`QQ(a)` but not for inexact domains like :ref:`RR` and :ref:`CC`. Examples ======== >>> from sympy import ZZ >>> from sympy.polys.matrices.ddm import ddm_idet >>> a = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(4), ZZ(5), ZZ(6)], [ZZ(7), ZZ(8), ZZ(9)]] >>> a [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> ddm_idet(a, ZZ) 0 >>> a [[1, 2, 3], [4, -3, -6], [7, -6, 0]] >>> [a[i][i] for i in range(len(a))] [1, -3, 0] See Also ======== sympy.polys.matrices.domainmatrix.DomainMatrix.det References ========== .. [1] https://en.wikipedia.org/wiki/Bareiss_algorithm .. [2] https://www.math.usm.edu/perry/Research/Thesis_DRL.pdf rrr:)r;rJrKr<rL) rrNr@rArKufrFrBakkm1r#rrrddm_idets,-    @r\csjstdt|}|sdSt|d|krtfddtD}ddt||D}t|}|ttkrAtdfdd|D|dd<dS) aainv <-- inv(a) Compute the inverse of a matrix $a$ over a field $K$ using Gauss-Jordan elimination. The result is stored in $ainv$. Uses division in the ground domain which should be an exact field. Examples ======== >>> from sympy.polys.matrices.ddm import ddm_iinv, ddm_imatmul >>> from sympy import QQ >>> a = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]] >>> ainv = [[None, None], [None, None]] >>> ddm_iinv(ainv, a, QQ) >>> ainv [[-2, 1], [3/2, -1/2]] >>> result = [[QQ(0), QQ(0)], [QQ(0), QQ(0)]] >>> ddm_imatmul(result, a, ainv) >>> result [[1, 0], [0, 1]] See Also ======== ddm_irref: the underlying routine. z Not a fieldNrcs$g|]fddtDqS)cs g|] }|kr jnjqSr)rJrL).0r#)rNrBrr s z'ddm_iinv...)r<)r]rNrA)rBrr^s$zddm_iinv..cSsg|]\}}||qSrr)r]roweyerowrrrr^z Matrix det == 0; not invertible.csg|]}|dqSr4rr]r`)rArrr^ rb) is_Fieldrr;rr<rrIrr)ainvrrNr@eyeAaugrCrr_rddm_iinvs rhc Cst|}|sgSt|d}t|}|jgt||}td|D]!}t||}||d|||d|<|d|||d|<q |S)aL, U <-- LU(U) Compute the LU decomposition of a matrix $L$ in place and store the lower and upper triangular matrices in $L$ and $U$, respectively. Returns a list of row swaps that were performed. Uses division in the ground domain which should be an exact field. Examples ======== >>> from sympy.polys.matrices.ddm import ddm_ilu_split >>> from sympy import QQ >>> L = [[QQ(0), QQ(0)], [QQ(0), QQ(0)]] >>> U = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]] >>> swaps = ddm_ilu_split(L, U, QQ) >>> swaps [] >>> L [[0, 0], [3, 0]] >>> U [[1, 2], [0, -2]] See Also ======== ddm_ilu ddm_ilu_solve rrN)r;ddm_ilurLminr<) LUrNr@rAswapszerosrBr#rrr ddm_ilu_split#s  roc Cst|}|sgSt|d}g}tt||D]e}|||sFt|d|D]}|||rD|||f||||||<||<nq&qt|d|D].}||||||}||||<t|d|D]}|||||||8<qhqMq|S)aa <-- LU(a) Computes the LU decomposition of a matrix in place. Returns a list of row swaps that were performed. Uses division in the ground domain which should be an exact field. This is only suitable for domains like :ref:`GF(p)`, :ref:`QQ`, :ref:`QQ_I` and :ref:`QQ(a)`. With a rational function field like :ref:`K(x)` it is better to clear denominators and use division-free algorithms. Pivoting is used to avoid exact zeros but not for floating point accuracy so :ref:`RR` and :ref:`CC` are not suitable (use :func:`ddm_irref` instead). Examples ======== >>> from sympy.polys.matrices.dense import ddm_ilu >>> from sympy import QQ >>> a = [[QQ(1, 2), QQ(1, 3)], [QQ(1, 4), QQ(1, 5)]] >>> swaps = ddm_ilu(a) >>> swaps [] >>> a [[1/2, 1/3], [1/2, 1/30]] The same example using ``Matrix``: >>> from sympy import Matrix, S >>> M = Matrix([[S(1)/2, S(1)/3], [S(1)/4, S(1)/5]]) >>> L, U, swaps = M.LUdecomposition() >>> L Matrix([ [ 1, 0], [1/2, 1]]) >>> U Matrix([ [1/2, 1/3], [ 0, 1/30]]) >>> swaps [] See Also ======== ddm_irref ddm_ilu_solve sympy.matrices.matrixbase.MatrixBase.LUdecomposition rr)r;r<rjr>) rr@rArmrBr6r#l_jirFrrrriQs,1    "ricst|}|sdSt|d}t|}|stdt|d||kr&td||kr.td|rKdd|D}|D]\}} || ||||<|| <q9fddt|D} tD]*} t|D]#} || | } t| D]}| || || || 8} ql| | | | <q`qZ||krt||D]} tD] }| | |rtqqtD]=} tt|D]4} || | st| | | } t| d|D]}| || |||| 8} q| || | || | <qqdS) ax <-- solve(L*U*x = swaps(b)) Solve a linear system, $A*x = b$, given an LU factorization of $A$. Uses division in the ground domain which must be a field. Modifies $x$ in place. Examples ======== Compute the LU decomposition of $A$ (in place): >>> from sympy import QQ >>> from sympy.polys.matrices.dense import ddm_ilu, ddm_ilu_solve >>> A = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]] >>> swaps = ddm_ilu(A) >>> A [[1, 2], [3, -2]] >>> L = U = A Solve the linear system: >>> b = [[QQ(5)], [QQ(6)]] >>> x = [[None], [None]] >>> ddm_ilu_solve(x, L, U, swaps, b) >>> x [[-4], [9/2]] See Also ======== ddm_ilu Compute the LU decomposition of a matrix in place. ddm_ilu_split Compute the LU decomposition of a matrix and separate $L$ and $U$. sympy.polys.matrices.domainmatrix.DomainMatrix.lu_solve Higher level interface to this function. Nrz Shape mismtchUnderdeterminedcSsg|]}|ddqSr4rrcrrrr^rbz!ddm_ilu_solve..csg|]}dgqSr4rr]_orrr^r)r;rNotImplementedErrorr<rreversed)xrkrlrmrr@rAm2i1i2yrFrBrhsr#rrtr ddm_ilu_solvesR(            rcst|}|s jggSt|d|krtddkr)jg|dd ggS|dd}|dddg}dd|ddD}dd|ddD}t|}fddtdD}tD]} j|| | <| || d| <qetd dD]>} | d kr|} n| }fd d|D} t| ||jgg} t| || tdd| D]} | dd || | | <qqfd dtdD} t| ||| S) a| Berkowitz algorithm for computing the characteristic polynomial. Explanation =========== The Berkowitz algorithm is a division-free algorithm for computing the characteristic polynomial of a matrix over any commutative ring using only arithmetic in the coefficient ring. Examples ======== >>> from sympy import Matrix >>> from sympy.polys.matrices.dense import ddm_berk >>> from sympy.polys.domains import ZZ >>> M = [[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]] >>> ddm_berk(M, ZZ) [[1], [-5], [-2]] >>> Matrix(M).charpoly() PurePoly(lambda**2 - 5*lambda - 2, lambda, domain='ZZ') See Also ======== sympy.polys.matrices.domainmatrix.DomainMatrix.charpoly The high-level interface to this function. References ========== .. [1] https://en.wikipedia.org/wiki/Samuelson%E2%80%93Berkowitz_algorithm rz Not squarerNcSsg|]}|dgqS)rrrcrrrr^!rvzddm_berk..cSsg|]}|ddqS)rNrrcrrrr^"rbcsg|]}jgqSrrLrrr_rrr^&rbcg|]}jgqSrrrcrNrrr^/crrrrrrrrr^6r)r;rJrddm_berkr<r3rL)MrNr@rr CAqr rBAnCRAnCr#qoutrr_rrs>"         rN)rrrr)rrrrrr)rrrr)rrrr rr)rrrrr/rrr)F) __doc__ __future__roperatorr exceptionsrrrrtypingr r sympy.polys.matrices._typingr r r rr%r'r*r,r.r3rIrYr\rhrorirrrrrrs2 $           =I/.K V