a RG5d@sdZddlmZmZmZmZmZddlmZddl m Z ddl m Z m Z mZddlmZGdd d eZd d Zd d ZddZddZddZddZddZddZdS)z Module for the SDM class. )addnegpossubmul) defaultdict)_strongly_connected_components)DMBadInputError DMDomainError DMShapeError)DDMcseZdZdZdZfddZddZddZd d Zd d Z d dZ ddZ e ddZ ddZe ddZe ddZddZddZddZdd Zd!d"Ze d#d$Ze d%d&Ze d'd(Ze d)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Z d9d:Z!d;d<Z"d=d>Z#d?d@Z$dAdBZ%dCdDZ&dEdFZ'dGdHZ(dIdJZ)dKdLZ*dMdNZ+dOdPZ,dQdRZ-dSdTZ.dUdVZ/dWdXZ0dYdZZ1d[d\Z2d]d^Z3d_d`Z4dadbZ5dcddZ6Z7S)eSDMaSparse 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}} sparsecspt|||_\|_|_\||_tfdd|DsJtdtfdd|DsltddS)Nc3s&|]}d|koknVqdSrN).0r)mrT/var/www/html/django/DPS/env/lib/python3.9/site-packages/sympy/polys/matrices/sdm.py IzSDM.__init__..zRow out of rangec3s0|](}|D]}d|ko knVq qdSrr)rrowcnrrrKrzColumn out of range) super__init__shaperowscolsdomainallr values)self elemsdictrr! __class__)rrrrDs z SDM.__init__c Csz|||WSty|j\}}| |kr<|krnnV| |krV|krnnxrz%SDM.extract_slice..)rrangeitemsr3newlenr!) r$slice1slice2rrrisdmr,rrr6r extract_sliceps   zSDM.extract_slicecCs|r |r |s&|t|t|f|jS|j\}}| t|krXt|krX|ksbntd| t|krt|kr|ksntdtt}tt}t |D]\}}||| |qt |D]\} } || | | qt |} t |} |} i}| t | @D]h}| |}i}| t |@D]&} || }|| D]} ||| <q@q,|r||D]}| ||<qbq| |t|t|f|jS)NzRow index out of rangezColumn index out of range)zerosr<r!rminmaxr+rlist enumerateappendsetcopyr;)r$rr rrZrowmapZcolmapi2i1j2j1ZrowsetcolsetZsdm1Zsdm2row1row2Zrow1_j1rrrextract~s8  **  z SDM.extractcCsNg}|D]2\}}ddd|D}|d||fq dd|S)Nz, css|]\}}d||fVqdS)z%s: %sNr)rr-elemrrrrrzSDM.__str__..z%s: {%s}z{%s})r:joinrG)r$rowsstrr,rZelemsstrrrr__str__s z SDM.__str__cCs(t|j}t|}d|||j|jfS)Nz%s(%s, %s, %s))type__name__dict__repr__rr!)r$clsrrrrrYs  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)rZr@rr!rrrr;szSDM.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: {}} cSsi|]\}}||qSrrI)rr,Airrrr8rzSDM.copy..)r:r;rr!)AZAcrrrrIszSDM.copycsp|\}t|kr*tfddDs2tdfddfddt|D}dd|D}||||S) ax 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}} c3s|]}t|kVqdSN)r<)rrrrrrrz SDM.from_list..zInconsistent row-list/shapecsfddtDS)Ncs&i|]}|r||qSrr)rr-)ddmr,rrr8rz3SDM.from_list....)r9r,)r_rr`rrzSDM.from_list..c3s|]}||fVqdSr^rrr,)getrowrrrrcSsi|]\}}|r||qSrrrr,rrrrr8rz!SDM.from_list..)r<r"r r9)rZr_rr!rZirowsr@r)r_rcrr from_lists"z SDM.from_listcCs|||j|jS)a converts object of :py:class:`~.DDM` to :py:class:`~.SDM` 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}} )rerr!)rZr_rrrfrom_ddmsz SDM.from_ddmcs^|j\}|jjfddt|D}|D]&\}}|D]\}}||||<qBq2|S)aC Converts a :py:class:`~.SDM` object to a list 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_rr*rr -rzSDM.to_list..)rr!r*r9r:)Mrr_r,rr-r5rrhrto_lists z SDM.to_listc CsX|j\}}|jj}|g||}|D]*\}}|D]\}}|||||<q8q(|Sr^)rr!r*r:) rjrrr*flatr,rr-r5rrr to_list_flat3s zSDM.to_list_flatcCsdd|DS)NcSs,i|]$\}}|D]\}}||f|qqSrr:)rr,rr-r5rrrr8=rzSDM.to_dok..rnrjrrrto_dok<sz SDM.to_dokcCst||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]] )r rkrr!rorrrto_ddm?sz SDM.to_ddmcCs|Sr^rrorrrto_sdmOsz SDM.to_sdmcCs |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)rZrr!rrrrBRsz SDM.zeroscsH|j}|\}}ttt||g|fddt|D}||||S)Ncsi|]}|qSrr[rbrrrr8nrzSDM.ones..)onerXzipr9)rZrr!rtrrr@rrsronesis zSDM.onescs6|\}}|jfddtt||D}||||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|]}||iqSrrrbrtrrr8rzSDM.eye..)rtr9rC)rZrr!rr r@rrwreyeqszSDM.eyecCsddt|D}||||S)NcSsi|]\}}|r|||iqSrr)rr,vrrrr8rzSDM.diag..)rF)rZdiagonalr!rr@rrrdiagszSDM.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_transposer;rr!)rjMTrrr transposesz SDM.transposecCst|tstS||Sr^) isinstancerNotImplementedrr]Brrr__add__s z SDM.__add__cCst|tstS||Sr^)rrrrrrrr__sub__s z SDM.__sub__cCs|Sr^)rr]rrr__neg__sz SDM.__neg__cCs0t|tr||S||jvr(||StSdS)zA * BN)rrmatmulr!rrrrrr__mul__s     z SDM.__mul__cCs||jvr||StSdSr^)r!rmulr)abrrr__rmul__s  z SDM.__rmul__cCsV|j|jkrt|j\}}|j\}}||kr0tt|||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 rr sdm_matmulr;)r]rrrn2oCrrrrs!   z SDM.matmulcs$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|Sr^raijrrrrarzSDM.mul.. unop_dictr;rr!r]rCsdmrrrrszSDM.mulcs$t|fdd}|||j|jS)Ncs|Sr^rrrrrrarzSDM.rmul..rrrrrrszSDM.rmulcsV|j|jkrt|j|jkr t|jjfdd}t||t||}|||j|jS)NcsSr^rr5r*rrrarz%SDM.mul_elementwise..)r!r rr r* binop_dictrr;)r]rfzerorrrrmul_elementwises   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}} )rrrr;rr!r]rrrrrrszSDM.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}} )rrrrr;rr!rrrrrszSDM.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}} )rrr;rr!)r]rrrrr*s zSDM.negcs:|jkr|St|fdd}|||jS)aO 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 |Sr^) convert_fromrKKoldrrraNrz SDM.convert_to..)r!rIrr;r)r]rAkrrr convert_to<s zSDM.convert_tocs:j\}}||ksJt|}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)rEr/)rryrrrr8erzSDM.scc..)rr9r)r]rr VZEmaprrrsccQs   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_irrefr;rr!)r]rpivotsrgrrrrrefhszSDM.rrefcCs||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}} )rfrqinvrrrrrzszSDM.invcCs |S)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 )rqdetrrrrrszSDM.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}}, []) )rqlurf)r]LUswapsrrrrszSDM.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}} )rfrqlu_solve)r]rrrrrsz SDM.lu_solvec Cs`|jd}|jj}t|\}}}t|||||\}}tt|}t||f}||||j|fS)aL Returns nullspace for a :py:class:`~.SDM` 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(2), 1: QQ(4)}}, (2, 2), QQ) >>> A.nullspace() ({0: {0: -2, 1: 1}}, [1]) r ) rr!rtrsdm_nullspace_from_rrefrXrFr<r;) r]ncolsrtrrnzcolsr nonpivotsrrrr nullspaces   z SDM.nullspacecCsL|jd}t|\}}}t|||}|r0d|ini}||d|df|jS)Nr r)rrsdm_particular_from_rrefr;r!)r]rrrrPreprrr particulars   zSDM.particularcGst|}|j\}}|j}|D]}|j\}}||ks:J|j|ksHJ|D]F\} } || d} | durxi|| <} | D]\} } | | | |<qqP||7}q ||||f|jS)aHorizontally 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.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)rXrIrr!r:r/r;)r]rAnewrr r!BkBkrowsBkcolsr,Bkir\r-ZBkijrrrhstacks       z SDM.hstackc Gst|}|j\}}|j}|D]N}|j\}}||ks:J|j|ksHJ|D]\} } | || |<qP||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}} )rXrIrr!r:r;) r]rrrr r!rrrr,rrrrvstacks     z SDM.vstackcs&fdd|D}|||j|S)Ncs(i|] \}}|fdd|DqS)csi|]\}}||qSrrr4funcrrr8$rz,SDM.applyfunc...rnrdrrrr8$rz!SDM.applyfunc..)r:r;r)r$rr!r@rrr applyfunc#sz SDM.applyfunccCs |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') )rqcharpolyrrrrr'sz SDM.charpolycCs| S)z@ Says whether this matrix has all zero entries. rr$rrris_zero_matrixBszSDM.is_zero_matrixcCstdd|DS)z~ Says whether this matrix is upper-triangular. True can be returned even if the matrix is not square. css$|]\}}|D]}||kVqqdSr^rrr,rr-rrrrMrzSDM.is_upper..r"r:rrrris_upperHsz SDM.is_uppercCstdd|DS)z~ Says whether this matrix is lower-triangular. True can be returned even if the matrix is not square. css$|]\}}|D]}||kVqqdSr^rrrrrrTrzSDM.is_lower..rrrrris_lowerOsz SDM.is_lower)8rW __module__ __qualname____doc__fmtrr.r2rArQrUrY classmethodr;rIrerfrkrmrprqrrrBrvrxr{rrrrrrrrrrrrrrrrrrrrrrrrrrrrr __classcell__rrr&rrst0  &  &       * %!rcCstt|t|}}i}||@D]}||||} } i} t| t| } } | | @D]"}|| || |}|rR|| |<qR| | D]}|| |}|r~|| |<q~| | D]}|| |}|r|| |<q| r| ||<q||D]B}||} i} | D]\}}||}|r|| |<q| r| ||<q||D]J}||} i} | D] \}}||}|r<|| |<q<| r$| ||<q$|Sr^)rHr:)r]rZfabfafbZAnzZBnzrr,r\BiCiZAnziZBnzir-CijAijBijrrrrWsN                rc CsPi}|D]>\}}i}|D]\}}||}|r |||<q |r |||<q |Sr^rn) r]frr,r\rr-rrrrrrs  rc Cs\i}|D]J\}}|D]8\}}z||||<WqtyR||i||<Yq0qq |Sr^)r:r))rjr~r,Mir-Mijrrrr}s r}cCs|jrt|||||Si}t|}|D]\}}i} t|} | |@D]p} || } || D]V\} }| | d}|dur|| |}|r|| | <q| | q^| |}|r^|| | <q^qF| r*| ||<q*|Sr^)is_EXRAWsdm_matmul_exrawrHr:r/pop)r]rrrrrB_knzr,r\rAi_knzkAikr-Bkjrrrrrs,       rc Cs|j}i}t|}|D]\}} tt} t| } | |@D]n} | | } || |kr~|| D]\}}| || |q`q>> 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:`~.Matrix` 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. css|]}|VqdSr^r[)rr\rrrrVrzsdm_irref..)keycsi|]\}}|vr||qSrr)rr-r)reduced_pivotsrrr8mrzsdm_irref..r|rr cSsi|]\}}||qSrr)rrprrrr8rcs(i|] \}}|tfdd|DqS)c3s|]}|VqdSr^r)rr pivot2rowrrrrz'sdm_irref...)rH)rrsrrrr8rcsg|] }|qSrrrb) pivot_row_maprrrirzsdm_irref..) sortedr#rCrHrrr:removerr<rFrX)r]ZArowsZnonreduced_pivotsZnonzero_columnsr\r-ZAjrZAinzZAjnzrrZAijinvlrZAkjZAknzZAklrrrr)rrrrrs|O                  rc Cshttt|t|}g}|D]>}||i}||dD]} || | ||| <q8||q ||fS)z%Get nullspace from A which is in RREFr)rrHr9r/rG) r]rtrrZ nonzero_colsrrr-ZKjr,rrrrs rcCsJi}t|D]8\}}|||dd}|dur ||||||<q |S)z1Get a particular solution from A which is in RREFr N)rFr/)r]rrrr,r-ZAinrrrrs rN)roperatorrrrrr collectionsrsympy.utilities.iterablesr exceptionsr r r r_r rXrrrr}rrrrrrrrrs*   L.  ,>5