o o hB@sdZddlmZmZmZmZmZddlmZddl m Z ddl m Z ddl mZddlmZmZmZdd lmZdd lmZe d krFd d gZGdddeZddZddZddZddZddZddZddZ ddZ!d d!Z"d"d#Z#d$d%Z$d&d'Z%d(S))z Module for the SDM class. )addnegpossubmul) defaultdict) GROUND_TYPES)doctest_depends_on)_strongly_connected_components)DMBadInputError DMDomainError DMShapeError)QQ)DDMflint SDM.to_dfmSDM.to_dfm_or_ddmcseZdZdZdZdZdZfddZddZdd Z d d Z d d Z ddZ ddZ eddZddZeddZeddZddZddZeddZd d!Zed"d#Zd$d%Zed&d'Zd(d)Zed*d+Zd,d-Zd.d/Zd0d1Zd2d3Ze d4gd5d6d7Z!e d4gd5d8d9Z"ed:d;Z#edd?Z%eddAdBZ&dCdDZ'dEdFZ(dGdHZ)dIdJZ*dKdLZ+dMdNZ,dOdPZ-dQdRZ.dSdTZ/dUdVZ0dWdXZ1dYdZZ2d[d\Z3d]d^Z4d_d`Z5dadbZ6dcddZ7dedfZ8dgdhZ9didjZ:dkdlZ;dmdnZdsdtZ?dudvZ@dwdxZAdydzZBd{d|ZCd}d~ZDddZEddZFddZGddZHeIddfddZJeIddfddZKZLS)SDMaSparse matrix based on polys domain elements This is a dict subclass and is a wrapper for a dict of dicts that supports basic matrix arithmetic +, -, *, **. In order to create a new :py:class:`~.SDM`, a dict of dicts mapping non-zero elements to their corresponding row and column in the matrix is needed. We also need to specify the shape and :py:class:`~.Domain` of our :py:class:`~.SDM` object. We declare a 2x2 :py:class:`~.SDM` matrix belonging to QQ domain as shown below. The 2x2 Matrix in the example is .. math:: A = \left[\begin{array}{ccc} 0 & \frac{1}{2} \\ 0 & 0 \end{array} \right] >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> elemsdict = {0:{1:QQ(1, 2)}} >>> A = SDM(elemsdict, (2, 2), QQ) >>> A {0: {1: 1/2}} We can manipulate :py:class:`~.SDM` the same way as a Matrix class >>> from sympy import ZZ >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ) >>> B = SDM({0:{0: ZZ(3)}, 1:{1:ZZ(4)}}, (2, 2), ZZ) >>> A + B {0: {0: 3, 1: 2}, 1: {0: 1, 1: 4}} Multiplication >>> A*B {0: {1: 8}, 1: {0: 3}} >>> A*ZZ(2) {0: {1: 4}, 1: {0: 2}} sparseFcspt|||_\|_|_\||_tfdd|Ds%tdtfdd|Ds6tddS)Nc3s(|]}d|ko knVqdSrN).0r)mrl/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/polys/matrices/sdm.py Ss&zSDM.__init__..zRow out of rangec3s2|]}|D]}d|koknVqqdSrr)rrowcnrrrUs0zColumn out of range) super__init__shaperowscolsdomainallr values)self elemsdictr#r& __class__)rr rr"Ns z SDM.__init__c Csz|||WStyT|j\}}| |kr|krPntd| |kr.|krPntdz |||||WYStyO|jjYYSwtdwNzindex out of range)KeyErrorr#r&zero IndexError)r)ijrr rrrgetitemXs   z SDM.getitemcCs|j\}}| |kr|kr$ntd| |kr#|ks(tdtd||||}}|rMz ||||<WdStyL||i||<YdSw||d}|durnz||=Wn tyfYdSw|sp||=dSdSdSr-)r#r0r.get)r)r1r2valuerr rowirrrsetitemes2      z SDM.setitemc s|j\}}t||}t||i}|D]\}}||vr3fdd|D}|r3||||<q||t|tf|jS)Ncs$i|]\}}|vr||qSr)indexrr2ecirr $z%SDM.extract_slice..)r#rangeitemsr8newlenr&) r)slice1slice2rr risdmr1rrr;r extract_slicezs   zSDM.extract_slicecCs|r|r|s|t|t|f|jS|j\}}| t|kr/t|kr/|ks4tdtd| t|krKt|krK|ksPtdtdtt}tt}t |D] \}}||| |q\t |D] \} } || | | qnt |} t |} |} i}| | @D]/}| |}i}| | @D]} || }|| D]} ||| <qq|r||D]}| ||<qq||t|t|f|jS)NzRow index out of rangezColumn index out of range)zerosrBr&r#minmaxr0rlist enumerateappendsetkeyscopyrA)r)r$r%rr rowmapcolmapi2i1j2j1rowsetcolsetsdm1sdm2row1row2row1_j1rrrextractsD  &&   z SDM.extractcCsNg}|D]\}}ddd|D}|d||fqdd|S)Nz, css |] \}}d||fVqdS)z%s: %sNr)rr2elemrrrrzSDM.__str__..z%s: {%s}z{%s})r@joinrM)r)rowsstrr1relemsstrrrr__str__s z SDM.__str__cCs(t|j}t|}d|||j|jfS)Nz%s(%s, %s, %s))type__name__dict__repr__r#r&)r)clsr$rrrrhs  z SDM.__repr__cCs ||||S)a Parameters ========== sdm: A dict of dicts for non-zero elements in SDM shape: tuple representing dimension of SDM domain: Represents :py:class:`~.Domain` of SDM Returns ======= An :py:class:`~.SDM` object Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> elemsdict = {0:{1: QQ(2)}} >>> A = SDM.new(elemsdict, (2, 2), QQ) >>> A {0: {1: 2}} r)rirFr#r&rrrrAs zSDM.newcCs$dd|D}|||j|jS)aT Returns the copy of a :py:class:`~.SDM` object Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> elemsdict = {0:{1:QQ(2)}, 1:{}} >>> A = SDM(elemsdict, (2, 2), QQ) >>> B = A.copy() >>> B {0: {1: 2}, 1: {}} cSi|] \}}||qSrrPrr1Airrrr=zSDM.copy..)r@rAr#r&)AAcrrrrPszSDM.copycsp|\}t|krtfddDstdfddfddt|D}dd|D}||||S) a" Create :py:class:`~.SDM` object from a list of lists. Parameters ========== ddm: list of lists containing domain elements shape: Dimensions of :py:class:`~.SDM` matrix domain: Represents :py:class:`~.Domain` of :py:class:`~.SDM` object Returns ======= :py:class:`~.SDM` containing elements of ddm Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> ddm = [[QQ(1, 2), QQ(0)], [QQ(0), QQ(3, 4)]] >>> A = SDM.from_list(ddm, (2, 2), QQ) >>> A {0: {0: 1/2}, 1: {1: 3/4}} See Also ======== to_list from_list_flat from_dok from_ddm c3s|] }t|kVqdSN)rB)rrrrrrz SDM.from_list..zInconsistent row-list/shapecsfddtDS)Ncs&i|]}|r||qSrrrr2)ddmr1rrr=s&z3SDM.from_list....)r?r1)rtr rurszSDM.from_list..c3s|] }||fVqdSrqrrr1)getrowrrrrrcSsi|] \}}|r||qSrrrr1rrrrr=rnz!SDM.from_list..)rBr'r r?)rirtr#r&rirowsrFr)rtrxr r from_lists'" z SDM.from_listcCs|||j|jS)a1 Create :py:class:`~.SDM` from a :py:class:`~.DDM`. Examples ======== >>> from sympy.polys.matrices.ddm import DDM >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> ddm = DDM( [[QQ(1, 2), 0], [0, QQ(3, 4)]], (2, 2), QQ) >>> A = SDM.from_ddm(ddm) >>> A {0: {0: 1/2}, 1: {1: 3/4}} >>> SDM.from_ddm(ddm).to_ddm() == ddm True See Also ======== to_ddm from_list from_list_flat from_dok )r{r#r&)rirtrrrfrom_ddmsz SDM.from_ddmcs^|j\}|jjfddt|D}|D]\}}|D] \}}||||<q!q|S)aL Convert a :py:class:`~.SDM` object to a list of lists. Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> elemsdict = {0:{1:QQ(2)}, 1:{}} >>> A = SDM(elemsdict, (2, 2), QQ) >>> A.to_list() [[0, 2], [0, 0]] csg|]}gqSrr)r_r r/rr GzSDM.to_list..)r#r&r/r?r@)Mrrtr1rr2r:rr~rto_list5s z SDM.to_listc CsX|j\}}|jj}|g||}|D]\}}|D] \}}|||||<qq|S)a Convert :py:class:`~.SDM` to a flat list. Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> A = SDM({0:{1:QQ(2)}, 1:{0: QQ(3)}}, (2, 2), QQ) >>> A.to_list_flat() [0, 2, 3, 0] >>> A == A.from_list_flat(A.to_list_flat(), A.shape, A.domain) True See Also ======== from_list_flat to_list to_dok to_ddm r#r&r/r@) rrr r/flatr1rr2r:rrr to_list_flatMs zSDM.to_list_flatc Csd|\}}t|||krtdtt}t|D]\}}|r+t||\} } ||| | <q||||S)a Create :py:class:`~.SDM` from a flat list of elements. Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> A = SDM.from_list_flat([QQ(0), QQ(2), QQ(0), QQ(0)], (2, 2), QQ) >>> A {0: {1: 2}} >>> A == A.from_list_flat(A.to_list_flat(), A.shape, A.domain) True See Also ======== to_list_flat from_list from_dok from_ddm zInconsistent flat-list shape)rBr rrgrLdivmod) rielementsr#r&rr rFinjelementr1r2rrrfrom_list_flatls  zSDM.from_list_flatcCs.|}t|}t|}||jf}||fS)aq Convert :class:`SDM` to a flat list of nonzero elements and data. Explanation =========== This is used to operate on a list of the elements of a matrix and then reconstruct a modified matrix with elements in the same positions using :meth:`from_flat_nz`. Zero elements are omitted from the list. Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> A = SDM({0:{1:QQ(2)}, 1:{0: QQ(3)}}, (2, 2), QQ) >>> elements, data = A.to_flat_nz() >>> elements [2, 3] >>> A == A.from_flat_nz(elements, data, A.domain) True See Also ======== from_flat_nz to_list_flat sympy.polys.matrices.ddm.DDM.to_flat_nz sympy.polys.matrices.domainmatrix.DomainMatrix.to_flat_nz )to_doktuplerKr(r#)rdokindicesrdatarrr to_flat_nzs   zSDM.to_flat_nzcCs$|\}}tt||}||||S)aE Reconstruct a :class:`~.SDM` after calling :meth:`to_flat_nz`. See :meth:`to_flat_nz` for explanation. See Also ======== to_flat_nz from_list_flat sympy.polys.matrices.ddm.DDM.from_flat_nz sympy.polys.matrices.domainmatrix.DomainMatrix.from_flat_nz )rgzipfrom_dok)rirrr&rr#rrrr from_flat_nzszSDM.from_flat_nzcCdd|DS)a Convert to dictionary of dictionaries (dod) format. Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> A = SDM({0: {1: QQ(2)}, 1: {0: QQ(3)}}, (2, 2), QQ) >>> A.to_dod() {0: {1: 2}, 1: {0: 3}} See Also ======== from_dod sympy.polys.matrices.domainmatrix.DomainMatrix.to_dod cSrjrrkryrrrr=rnzSDM.to_dod..r@rrrrto_dodsz SDM.to_dodc CsHtt}|D]\}}|D] \}}|r||||<qq||||S)a Create :py:class:`~.SDM` from dictionary of dictionaries (dod) format. Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> dod = {0: {1: QQ(2)}, 1: {0: QQ(3)}} >>> A = SDM.from_dod(dod, (2, 2), QQ) >>> A {0: {1: 2}, 1: {0: 3}} >>> A == SDM.from_dod(A.to_dod(), A.shape, A.domain) True See Also ======== to_dod sympy.polys.matrices.domainmatrix.DomainMatrix.to_dod rrgr@) ridodr#r&rFr1rr2r:rrrfrom_dods  z SDM.from_dodcCr)a Convert to dictionary of keys (dok) format. Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> A = SDM({0: {1: QQ(2)}, 1: {0: QQ(3)}}, (2, 2), QQ) >>> A.to_dok() {(0, 1): 2, (1, 0): 3} See Also ======== from_dok to_list to_list_flat to_ddm cSs,i|]\}}|D] \}}||f|q qSrr)rr1rr2r:rrrr=s,zSDM.to_dok..rrrrrrsz SDM.to_dokcCs:tt}|D]\\}}}|r||||<q||||S)a  Create :py:class:`~.SDM` from dictionary of keys (dok) format. Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> dok = {(0, 1): QQ(2), (1, 0): QQ(3)} >>> A = SDM.from_dok(dok, (2, 2), QQ) >>> A {0: {1: 2}, 1: {0: 3}} >>> A == SDM.from_dok(A.to_dok(), A.shape, A.domain) True See Also ======== to_dok from_list from_list_flat from_ddm r)rirr#r&rFr1r2r:rrrrs   z SDM.from_dokccs"|D] }|EdHqdS)a< Iterate over the nonzero values of a :py:class:`~.SDM` matrix. Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> A = SDM({0: {1: QQ(2)}, 1: {0: QQ(3)}}, (2, 2), QQ) >>> list(A.iter_values()) [2, 3] N)r()rrrrr iter_values/s zSDM.iter_valuesccs8|D]\}}|D] \}}||f|fVq qdS)a Iterate over indices and values of the nonzero elements. Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> A = SDM({0: {1: QQ(2)}, 1: {0: QQ(3)}}, (2, 2), QQ) >>> list(A.iter_items()) [((0, 1), 2), ((1, 0), 3)] See Also ======== sympy.polys.matrices.domainmatrix.DomainMatrix.iter_items Nr)rr1rr2r:rrr iter_items@s zSDM.iter_itemscCst||j|jS)a2 Convert a :py:class:`~.SDM` object to a :py:class:`~.DDM` object Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ) >>> A.to_ddm() [[0, 2], [0, 0]] )rrr#r&rrrrto_ddmVsz SDM.to_ddmcCs|S)zE Convert to :py:class:`~.SDM` format (returns self). rrrrrto_sdmfsz SDM.to_sdmr) ground_typescC |S)a Convert a :py:class:`~.SDM` object to a :py:class:`~.DFM` object Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ) >>> A.to_dfm() [[0, 2], [0, 0]] See Also ======== to_ddm to_dfm_or_ddm sympy.polys.matrices.domainmatrix.DomainMatrix.to_dfm )rto_dfmrrrrrl rcCr)a3 Convert to :py:class:`~.DFM` if possible, else :py:class:`~.DDM`. Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ) >>> A.to_dfm_or_ddm() [[0, 2], [0, 0]] >>> type(A.to_dfm_or_ddm()) # depends on the ground types See Also ======== to_ddm to_dfm sympy.polys.matrices.domainmatrix.DomainMatrix.to_dfm_or_ddm )r to_dfm_or_ddmrrrrrs rcCs |i||S)a Returns a :py:class:`~.SDM` of size shape, belonging to the specified domain In the example below we declare a matrix A where, .. math:: A := \left[\begin{array}{ccc} 0 & 0 & 0 \\ 0 & 0 & 0 \end{array} \right] >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> A = SDM.zeros((2, 3), QQ) >>> A {} r)rir#r&rrrrHrz SDM.zeroscsH|j}|\}}ttt||g|fddt|D}||||S)Ncsi|]}|qSrrkrwrrrr=rzSDM.ones..)onergrr?)rir#r&rrr rFrrroness  zSDM.onescsPt|tr ||}}n|\}}|jfddtt||D}||||f|S)aO Returns a identity :py:class:`~.SDM` matrix of dimensions size x size, belonging to the specified domain Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> I = SDM.eye((2, 2), QQ) >>> I {0: {0: 1}, 1: {1: 1}} csi|]}||iqSrrrwrrrr=rzSDM.eye..) isinstanceintrr?rI)rir#r&r$r%rFrrreyes  zSDM.eyeNcCs6|dur t|t|f}ddt|D}||||S)NcSsi|] \}}|r|||iqSrr)rr1vrrrr=zSDM.diag..)rBrL)ridiagonalr&r#rFrrrdiags zSDM.diagcCs$t|}|||jddd|jS)a$ Returns the transpose of a :py:class:`~.SDM` matrix Examples ======== >>> from sympy.polys.matrices.sdm import SDM >>> from sympy import QQ >>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ) >>> A.transpose() {1: {0: 2}} N) sdm_transposerAr#r&)rMTrrr transposesz SDM.transposecC8t|tstS|j|jkrtd|j|jf||S)NzMatrix size mismatch: %s + %s)rrNotImplementedr#rrroBrrr__add__   z SDM.__add__cCr)NzMatrix size mismatch: %s - %s)rrrr#rrrrrr__sub__rz SDM.__sub__cCs|Srq)rrorrr__neg__sz SDM.__neg__cCs,t|tr ||S||jvr||StS)zA * B)rrmatmulr&rrrrrr__mul__s    z SDM.__mul__cCs||jvr ||StSrq)r&rmulr)abrrr__rmul__s  z SDM.__rmul__cCsV|j|jkrt|j\}}|j\}}||krtt|||j||}||||f|jS)a Performs matrix multiplication of two SDM matrices Parameters ========== A, B: SDM to multiply Returns ======= SDM SDM after multiplication Raises ====== DomainError If domain of A does not match with that of B Examples ======== >>> from sympy import ZZ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ) >>> B = SDM({0:{0:ZZ(2), 1:ZZ(3)}, 1:{0:ZZ(4)}}, (2, 2), ZZ) >>> A.matmul(B) {0: {0: 8}, 1: {0: 2, 1: 3}} )r&r r#r sdm_matmulrA)rorrr n2oCrrrr s !  z SDM.matmulc$t|fdd}|||j|jS)a. Multiplies each element of A with a scalar b Examples ======== >>> from sympy import ZZ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ) >>> A.mul(ZZ(3)) {0: {1: 6}, 1: {0: 3}} cs|SrqraijrrrrvEzSDM.mul.. unop_dictrAr#r&rorCsdmrrrr7szSDM.mulcr)Ncs|SrqrrrrrrvIrzSDM.rmul..rrrrrrHszSDM.rmulcsV|j|jkrt|j|jkrt|jjfdd}t||t||}|||j|jS)NcsSrqrr:r/rrrvRsz%SDM.mul_elementwise..)r&r r#rr/ binop_dictrrA)rorfzerorrrrmul_elementwiseLs   zSDM.mul_elementwisecCs"t||ttt}|||j|jS)ak Adds two :py:class:`~.SDM` matrices Examples ======== >>> from sympy import ZZ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ) >>> B = SDM({0:{0: ZZ(3)}, 1:{1:ZZ(4)}}, (2, 2), ZZ) >>> A.add(B) {0: {0: 3, 1: 2}, 1: {0: 1, 1: 4}} )rrrrAr#r&rorrrrrrVzSDM.addcCs"t||ttt}|||j|jS)as Subtracts two :py:class:`~.SDM` matrices Examples ======== >>> from sympy import ZZ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ) >>> B = SDM({0:{0: ZZ(3)}, 1:{1:ZZ(4)}}, (2, 2), ZZ) >>> A.sub(B) {0: {0: -3, 1: 2}, 1: {0: 1, 1: -4}} )rrrrrAr#r&rrrrrirzSDM.subcCst|t}|||j|jS)a2 Returns the negative of a :py:class:`~.SDM` matrix Examples ======== >>> from sympy import ZZ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ) >>> A.neg() {0: {1: -2}, 1: {0: -1}} )rrrAr#r&)rorrrrr|s zSDM.negcs:|jkr |St|fdd}|||jS)aN Converts the :py:class:`~.Domain` of a :py:class:`~.SDM` matrix to K Examples ======== >>> from sympy import ZZ, QQ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ) >>> A.convert_to(QQ) {0: {1: 2}, 1: {0: 1}} cs |Srq) convert_fromrKKoldrrrvs z SDM.convert_to..)r&rPrrAr#)rorAkrrr convert_tos zSDM.convert_tocCsttt|S)ayNumber of non-zero elements in the :py:class:`~.SDM` matrix. Examples ======== >>> from sympy import ZZ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ) >>> A.nnz() 2 See Also ======== sympy.polys.matrices.domainmatrix.DomainMatrix.nnz )summaprBr(rrrrnnzszSDM.nnzcs:j\}}||ks Jt|}fdd|D}t||S)a{Strongly connected components of a square matrix *A*. Examples ======== >>> from sympy import ZZ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{0: ZZ(2)}, 1:{1:ZZ(1)}}, (2, 2), ZZ) >>> A.scc() [[0], [1]] See also ======== sympy.polys.matrices.domainmatrix.DomainMatrix.scc csi|] }|t|gqSr)rKr4)rrrrrr=rzSDM.scc..)r#r?r )ror$r%VEmaprrrsccs   zSDM.scccCs$t|\}}}|||j|j|fS)a_ Returns reduced-row echelon form and list of pivots for the :py:class:`~.SDM` Examples ======== >>> from sympy import QQ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(2), 1:QQ(4)}}, (2, 2), QQ) >>> A.rref() ({0: {0: 1, 1: 2}}, [0]) ) sdm_irrefrAr#r&)rorpivotsr}rrrrrefszSDM.rrefcCs2|j}t||\}}}|||j|j}|||fS)a] Returns reduced-row echelon form (RREF) with denominator and pivots. Examples ======== >>> from sympy import QQ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(2), 1:QQ(4)}}, (2, 2), QQ) >>> A.rref_den() ({0: {0: 1, 1: 2}}, 1, [0]) )r& sdm_rref_denrAr#)ror A_rref_sdmdenomrA_rrefrrrrref_dens z SDM.rref_dencCs|S)a> Returns inverse of a matrix A Examples ======== >>> from sympy import QQ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ) >>> A.inv() {0: {0: -2, 1: 1}, 1: {0: 3/2, 1: -1/2}} )rinvrrrrrrszSDM.invcCr)a Returns determinant of A Examples ======== >>> from sympy import QQ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ) >>> A.det() -2 )rdetrrrrrrzSDM.detcCs(|\}}}|||||fS)a` Returns LU decomposition for a matrix A Examples ======== >>> from sympy import QQ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ) >>> A.lu() ({0: {0: 1}, 1: {0: 3, 1: 1}}, {0: {0: 1, 1: 2}, 1: {1: -2}}, []) )rlur|)roLUswapsrrrrszSDM.lucCs|||S)an Uses LU decomposition to solve Ax = b, Examples ======== >>> from sympy import QQ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ) >>> b = SDM({0:{0:QQ(1)}, 1:{0:QQ(2)}}, (2, 1), QQ) >>> A.lu_solve(b) {1: {0: 1/2}} )r|rlu_solve)rorrrrr,sz SDM.lu_solvec Cs`|jd}|jj}t|\}}}t|||||\}}tt|}t||f}||||j|fS)a Nullspace of a :py:class:`~.SDM` matrix A. The domain of the matrix must be a field. It is better to use the :meth:`~.DomainMatrix.nullspace` method rather than this method which is otherwise no longer used. Examples ======== >>> from sympy import QQ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0: QQ(2), 1: QQ(4)}}, (2, 2), QQ) >>> A.nullspace() ({0: {0: -2, 1: 1}}, [1]) See Also ======== sympy.polys.matrices.domainmatrix.DomainMatrix.nullspace The preferred way to get the nullspace of a matrix. r ) r#r&rrsdm_nullspace_from_rrefrgrLrBrA) roncolsrrrnzcolsr nonpivotsr#rrr nullspace>s   z SDM.nullspacecCsT|j\}}|j}|durttt|}|s%|||f|tt|fSt ||kr5| d|f|gfS|d|d}| |rDJt |}t t}|D]\}} | D] \} } || || fqXqPg} g} t|D]%} | |vrvqo| | | |i}|| D] \}} | |||<q| |qott| }||t | |f|}|| fS)a\ Returns nullspace for a :py:class:`~.SDM` matrix ``A`` in RREF. The domain of the matrix can be any domain. The matrix must already be in reduced row echelon form (RREF). Examples ======== >>> from sympy import QQ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0: QQ(2), 1: QQ(4)}}, (2, 2), QQ) >>> A_rref, pivots = A.rref() >>> A_null, nonpivots = A_rref.nullspace_from_rref(pivots) >>> A_null {0: {0: -2, 1: 1}} >>> pivots [0] >>> nonpivots [1] See Also ======== sympy.polys.matrices.domainmatrix.DomainMatrix.nullspace The higher-level function that would usually be called instead of calling this one directly. sympy.polys.matrices.domainmatrix.DomainMatrix.nullspace_from_rref The higher-level direct equivalent of this function. sympy.polys.matrices.ddm.DDM.nullspace_from_rref The equivalent function for dense :py:class:`~.DDM` matrices. Nr)r#r&sortedrrIr(rrKr?rBrHis_zerorNrr@rMrgrLrA)rorrr r pivot_val pivots_set nonzero_colsr1rmr2AijbasisrveciprFA_nullrrrnullspace_from_rref`s: %      zSDM.nullspace_from_rrefcCsL|jd}t|\}}}t|||}|rd|ini}||d|df|jS)Nr r)r#rsdm_particular_from_rrefrAr&)rorrrrPreprrr particulars  zSDM.particularcGst|}|j\}}|j}|D]@}|j\}}||ksJ|j|ks$J|D]#\} } || d} | dur>> from sympy import ZZ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}, (2, 2), ZZ) >>> B = SDM({0: {0: ZZ(5), 1: ZZ(6)}, 1: {0: ZZ(7), 1: ZZ(8)}}, (2, 2), ZZ) >>> A.hstack(B) {0: {0: 1, 1: 2, 2: 5, 3: 6}, 1: {0: 3, 1: 4, 2: 7, 3: 8}} >>> C = SDM({0: {0: ZZ(9), 1: ZZ(10)}, 1: {0: ZZ(11), 1: ZZ(12)}}, (2, 2), ZZ) >>> A.hstack(B, C) {0: {0: 1, 1: 2, 2: 5, 3: 6, 4: 9, 5: 10}, 1: {0: 3, 1: 4, 2: 7, 3: 8, 4: 11, 5: 12}} N)rgrPr#r&r@r4rA)rorAnewr$r%r&BkBkrowsBkcolsr1Bkirmr2Bkijrrrhstacks       z SDM.hstackc Gst|}|j\}}|j}|D]'}|j\}}||ksJ|j|ks$J|D] \} } | || |<q(||7}q||||f|jS)aVertically stacks :py:class:`~.SDM` matrices. Examples ======== >>> from sympy import ZZ >>> from sympy.polys.matrices.sdm import SDM >>> A = SDM({0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}, (2, 2), ZZ) >>> B = SDM({0: {0: ZZ(5), 1: ZZ(6)}, 1: {0: ZZ(7), 1: ZZ(8)}}, (2, 2), ZZ) >>> A.vstack(B) {0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}, 2: {0: 5, 1: 6}, 3: {0: 7, 1: 8}} >>> C = SDM({0: {0: ZZ(9), 1: ZZ(10)}, 1: {0: ZZ(11), 1: ZZ(12)}}, (2, 2), ZZ) >>> A.vstack(B, C) {0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}, 2: {0: 5, 1: 6}, 3: {0: 7, 1: 8}, 4: {0: 9, 1: 10}, 5: {0: 11, 1: 12}} )rgrPr#r&r@rA) rorrr$r%r&rrrr1r rrrvstacks     z SDM.vstackcs&fdd|D}|||j|S)Ncs(i|]\}}|fdd|DqS)csi|] \}}||qSrrr9funcrrr=rnz,SDM.applyfunc...rryr rrr=s(z!SDM.applyfunc..)r@rAr#)r)rr&rFrr r applyfuncsz SDM.applyfunccCsJ|j}|j\}}t|||}|jg|d}|D]\}}|||<q|S)a Returns the coefficients of the characteristic polynomial of the :py:class:`~.SDM` matrix. These elements will be domain elements. The domain of the elements will be same as domain of the :py:class:`~.SDM`. Examples ======== >>> from sympy import QQ, Symbol >>> from sympy.polys.matrices.sdm import SDM >>> from sympy.polys import Poly >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ) >>> A.charpoly() [1, -5, -2] We can create a polynomial using the coefficients using :py:class:`~.Poly` >>> x = Symbol('x') >>> p = Poly(A.charpoly(), x, domain=A.domain) >>> p Poly(x**2 - 5*x - 2, x, domain='QQ') r )r&r#sdm_berkr/r@)rorr r}pdictplistr1pirrrcharpolys   z SDM.charpolycCs| S)z@ Says whether this matrix has all zero entries. rr)rrris_zero_matrix)szSDM.is_zero_matrixcCtdd|DS)z~ Says whether this matrix is upper-triangular. True can be returned even if the matrix is not square. css&|]\}}|D]}||kVqqdSrqrrr1rr2rrrr4$zSDM.is_upper..r'r@rrrris_upper/z SDM.is_uppercCr)z~ Says whether this matrix is lower-triangular. True can be returned even if the matrix is not square. css&|]\}}|D]}||kVqqdSrqrrrrrr;rzSDM.is_lower..rrrrris_lower6rz SDM.is_lowercCr)zv Says whether this matrix is diagonal. True can be returned even if the matrix is not square. css&|]\}}|D]}||kVqqdSrqrrrrrrBrz"SDM.is_diagonal..rrrrr is_diagonal=rzSDM.is_diagonalcs*|j\}|jjfdd|DS)z? Returns the diagonal of the matrix as a list. cs$g|]\}}|kr||qSr)r4ryr~rrrJr>z SDM.diagonal..r)r)rrr~rrDs z SDM.diagonalcCs|j|dS)zQ Returns the LLL-reduced basis for the :py:class:`~.SDM` matrix. delta)rlllr)ror"rrrr#LszSDM.lllcCs$|j|d\}}||fS)zJ Returns the LLL-reduced basis and transformation matrix. r!)r lll_transformr)ror"reduced transformrrrr$RszSDM.lll_transformrq)Mrf __module__ __qualname____doc__fmtis_DFMis_DDMr"r3r7rGr^rdrh classmethodrArPr{r|rrrrrrrrrrrrrr rrrHrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rrrrrrrrr#r$ __classcell__rrr+rrs0   &  .  !%            *  "W%!!rcCslt|t|}}i}||@D]X}||||} } i} t| t| } } | | @D]}|| || |}|r:|| |<q)| | D]}|| |}|rM|| |<q?| | D]}|| |}|r`|| |<qR| rg| ||<q||D]!}||} i} | D]\}}||}|r|| |<qx| r| ||<ql||D]!}||} i} | D]\}}||}|r|| |<q| r| ||<q|Srq)rNr@)rorfabfafbAnzBnzrr1rmBiCiAnziBnzir2CijrBijrrrrZs^        rc CsPi}|D]\}}i}|D]\}}||}|r|||<q|r%|||<q|Srqr) rofrr1rmr4r2rr9rrrrsrc CsZi}|D]$\}}|D]\}}z||||<Wqty)||i||<Yqwq|Srq)r@r.)rrr1Mir2Mijrrrrs rcs&|fdd@DS)Nc3s |] }||VqdSrqrrsrrrrr`zsdm_dotvec..)rrO)rorrrrr sdm_dotvecs&r=cCs2i}|D]\}}t|||}|r|||<q|Srq)r@r=)rorrrr1rmr5rrr sdm_matvecmuls r>cCs|jr t|||||Si}t|}|D]M\}}i} t|} | |@D]8} || } || D]+\} }| | d}|durP|| |}|rJ|| | <q/| | q/| |}|rZ|| | <q/q#| rb| ||<q|Srq)is_EXRAWsdm_matmul_exrawrNr@r4pop)rorrrrrB_knzr1rmr5Ai_knzkAikr2Bkjr8rrrrs2      rc Cs|j}i}t|}|D]\}} tt} t| } | |@D]7} | | } || |kr>|| D] \}}| || |q/qt|D]}| || || ||qBq| |D]} || | }||krst|D] }| ||qiqYi}| D]\}}||}|r|||<qz|r|||<q |D]G\} }|D]>\}}|||krt|D]/}||i| |} | |kr||i}|||| |}||kr|||<nt |||<qqq|Srq) r/rNr@rrKrMr?r4r RuntimeError)rorrrrr/rrBr1rmCi_listrCrDrEr2rFzAikr5Cij_listr8rrrrr@sZ            r@cstdd|Dtd}itt}tt}|r4|}fdd|D}|t|@D]I}|}||}t|}t|} | |D] } | || || <qG||||| |@D]} || ||| } | rt| || <qa|| qaq1|s~qt|}||}||<t|}|d} |D] } || | 9<q||dD]h} | }||}t|}||D]} | || || <|| | q||||||@D]#} || ||| }|r||| <q|| | |kr|| | qt |dkr | || qt |dkr|n|||D]} | |kr0|| |q"|st|B}d dt |Dfd d|D}fd d |D}t t |}|||fS) aRREF and pivots of a sparse matrix *A*. Compute the reduced row echelon form (RREF) of the matrix *A* and return a list of the pivot columns. This routine does not work in place and leaves the original matrix *A* unmodified. The domain of the matrix must be a field. Examples ======== This routine works with a dict of dicts sparse representation of a matrix: >>> from sympy import QQ >>> from sympy.polys.matrices.sdm import sdm_irref >>> A = {0: {0: QQ(1), 1: QQ(2)}, 1: {0: QQ(3), 1: QQ(4)}} >>> Arref, pivots, _ = sdm_irref(A) >>> Arref {0: {0: 1}, 1: {1: 1}} >>> pivots [0, 1] The analogous calculation with :py:class:`~.MutableDenseMatrix` would be >>> from sympy import Matrix >>> M = Matrix([[1, 2], [3, 4]]) >>> Mrref, pivots = M.rref() >>> Mrref Matrix([ [1, 0], [0, 1]]) >>> pivots (0, 1) Notes ===== The cost of this algorithm is determined purely by the nonzero elements of the matrix. No part of the cost of any step in this algorithm depends on the number of rows or columns in the matrix. No step depends even on the number of nonzero rows apart from the primary loop over those rows. The implementation is much faster than ddm_rref for sparse matrices. In fact at the time of writing it is also (slightly) faster than the dense implementation even if the input is a fully dense matrix so it seems to be faster in all cases. The elements of the matrix should support exact division with ``/``. For example elements of any domain that is a field (e.g. ``QQ``) should be fine. No attempt is made to handle inexact arithmetic. See Also ======== sympy.polys.matrices.domainmatrix.DomainMatrix.rref The higher-level function that would normally be used to call this routine. sympy.polys.matrices.dense.ddm_irref The dense equivalent of this routine. sdm_rref_den Fraction-free version of this routine. css|]}|VqdSrqrk)rrmrrrrrszsdm_irref..keyci|] \}}|vr||qSrrrr2r)reduced_pivotsrrr=rzsdm_irref..rrr cSi|]\}}||qSrr)rr prrrr=rcs$i|]\}}|fdd|DqS)csh|]}|qSrr)rrQ pivot2rowrr z'sdm_irref...r)rrsrRrrr=r>csg|]}|qSrrrw) pivot_row_maprrrrUzsdm_irref..) rr(rIrNrrAr@removerrBrLrg)roArowsnonreduced_pivotsnonzero_columnsrmr2AjrAinzAjnzrDrEAijinvlrAkjAknzAklrr$rr)rSrWrOrrs[                   K  rc$sJ|si|jgfSt|dkr%|\}t|}||}d|i||gfS|jr,|j}n|j}tt | \}}i}i} | | } g} d} d} t |td}|D]}fdd| D}i}| | @D]8}| |}| | |}| D]&\}}| |}|dur||||<qz|||}|r|||<qz| |qzqit|}t|}| p|j}||D] }|| ||<q||D] }|||||<q||@D]}|||||}|r|||<q| |q|sqSt|}| |}t| D]\}}| |}||vr%| D]\}}||}| dur||| }|||<q q| |}t|}t|}||D]}| ||||<| durO|||| ||<q6||D]}|||||<| durm|||| ||<qU||@D]'}||||||}|r| dur||| }|||<qs| |qs|s| ||||<qt| }| ||r|| |<n|||<||s| dur|} n| |9} | dur|| | } | } qS| dur|j} i|| }dd| Dfdd t| D} tt | \}!}"t|!}!t|"D] \}}| ||!|<qtt|"}#|#| |!fS) a? Return the reduced row echelon form (RREF) of A with denominator. The RREF is computed using fraction-free Gauss-Jordan elimination. 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. This implementation is also optimized for sparse matrices. 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.sdm import sdm_rref_den >>> from sympy.polys.domains import ZZ >>> A = {0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}} >>> A_rref, den, pivots = sdm_rref_den(A, ZZ) >>> A_rref {0: {0: -2}, 1: {1: -2}} >>> den -2 >>> pivots [0, 1] See Also ======== sympy.polys.matrices.domainmatrix.DomainMatrix.rref_den Higher-level interface to ``sdm_rref_den`` that would usually be used instead of calling this function directly. sympy.polys.matrices.sdm.sdm_rref_den The ``SDM`` method that uses this function. sdm_irref Computes RREF using field division. ddm_irref_den The dense version of this algorithm. 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 r rNrKcrMrrrN)r%rrr=Zrz sdm_rref_den..cSrPrr)rr2r1rrrr=rcsg|] \}}||fqSrrrl) row_to_colrrrsz sdm_rref_den..)rrBr(rIrPis_Exactexquoquorrr@rOrAr4rNrKrMis_onerLrg)$rorrmr2rrfr} rows_in_ordercol_to_row_reducedcol_to_row_unreduced unreduced A_rref_rowsrdivisorA_rows Ai_cancelr\rDAjk Aik_cancelAi_nz Ai_cancel_nzdrEpkrr`rcraAk_nzr1 col_to_rowA_rref_rows_colrrrr)r%rdrrs]                                            rc Cshttt|t|}g}|D]}||i}||dD] } || | ||| <q||q||fS)z%Get nullspace from A which is in RREFr)rrNr?r4rM) rorrrrrrr2Kjr1rrrrs rcCsJi}t|D]\}}|||dd}|dur"||||||<q|S)z1Get a particular solution from A which is in RREFr N)rLr4)rorrrr1r2AinrrrrsrcCs|j}|j}|dkrd|iS|dkr'd|i}|did|}r'| |d<|jiittf\}}} } |D]0\} } | D]'\} }| rS| rS|| | d| d<q@| r\|| | d<q@| re||| d<q@|}q@q8| }t|| |}|| | g}td|dD]} t| ||}|sn t|||}| | q|r|ds| |r|drt | |d|}|ddd}i}tt |t t |t||dD]} tt|| t|d}t|||}r||| <q|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. This implementation is for sparse matrices represented in a dict-of-dicts format (like :class:`SDM`). Examples ======== >>> from sympy import Matrix >>> from sympy.polys.matrices.sdm import sdm_berk >>> from sympy.polys.domains import ZZ >>> M = {0: {0: ZZ(1), 1:ZZ(2)}, 1: {0:ZZ(3), 1:ZZ(4)}} >>> sdm_berk(M, 2, ZZ) {0: 1, 1: -5, 2: -2} >>> Matrix([[1, 2], [3, 4]]).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. sympy.polys.matrices.dense.ddm_berk The dense version of this function. References ========== .. [1] https://en.wikipedia.org/wiki/Samuelson%E2%80%93Berkowitz_algorithm rr rrN)r/rr4rrgr@r=r?r>rMrArrIrJrBrL)rr rr/rrM00rRrror1r;r2r<AnCRCTvalsRAnCqTqTiTqirrrrsP%      (rN)&r)operatorrrrrr collectionsrsympy.external.gmpyrsympy.utilities.decoratorr sympy.utilities.iterablesr exceptionsr r rsympy.polys.domainsrrtr__doctest_skip__rgrrrrr=r>rr@rrrrrrrrrsJ      K.   ,>A