+ i0^RIHt^RIHt^RIHtHt^RIHtH t H t H t ^RI H t RRltRRlt] 3R lt] R R 3R lt] R 3R ltR tRt] R RR3RltR#)) FunctionType)CoercionFailed)ZZQQ)_get_intermediate_simp_iszero _dotprodsimp _simplify)_find_reasonable_pivotTc aaaVV3Rlp VV3Rlp VVV3Rlp \\4o^^r.p.pV S8EdpW8Edi\V !V 4V RWE4wppppVF"wppVV , pVSVS,V ,&K$ Vf V ^, p K`VPV 4V^8wd+V !V VV ,4VPV VV ,34VRJdhYppVSVS,V,&\ VS,V,^,V^,S,4FpS!SV,V, 4SV&K Tp\ V4FMpVV 8XdK VRJd VV 8dKSVS,V ,,pV!V4'dKBV !VVVV 4KO V ^, p EKwVRJdVRJd\ V4FwppSVS,V,,pVSVS,V,&\ VS,V,^,V^,S,4FpS!SV,V, 4SV&K K S\ V4\ V43#)a{Row reduce a flat list representation of a matrix and return a tuple (rref_matrix, pivot_cols, swaps) where ``rref_matrix`` is a flat list, ``pivot_cols`` are the pivot columns and ``swaps`` are any row swaps that were used in the process of row reduction. Parameters ========== mat : list list of matrix elements, must be ``rows`` * ``cols`` in length rows, cols : integer number of rows and columns in flat list representation one : SymPy object represents the value one, from ``Matrix.one`` iszerofunc : determines if an entry can be used as a pivot simpfunc : used to simplify elements and test if they are zero if ``iszerofunc`` returns `None` normalize_last : indicates where all row reduction should happen in a fraction-free manner and then the rows are normalized (so that the pivots are 1), or whether rows should be normalized along the way (like the naive row reduction algorithm) normalize : whether pivot rows should be normalized so that the pivot value is 1 zero_above : whether entries above the pivot should be zeroed. If ``zero_above=False``, an echelon matrix will be returned. c<SVRS1,#N)icolsmats&y/Users/tonyclaw/.openclaw/workspace/skills/math-calculator/venv/lib/python3.14/site-packages/sympy/matrices/reductions.pyget_col!_row_reduce_list..get_col/s17d7|c<SVS,V^,S,SVS,V^,S,uSVS,V^,S,%SVS,V^,S,%R#)Nr)rjrrs&&rrow_swap"_row_reduce_list..row_swap2s] $At| $c!D&!a%&> ;AdFAE4< #afa!eT\":rc<W1, S,p\VS,V^,S,4F7pS!VSV,,VSWT,,,, 4SV&K9 R#)z,Does the row op row[i] = a*row[i] - b*row[j]N)range) arbrqprisimprs &&&& r cross_cancel&_row_reduce_list..cross_cancel6sP UDLqvAt|,A1SV8aAE l23CF-rNFT)rr r appendr enumeratetuple)rrowsrone iszerofuncsimpfuncnormalize_last normalize zero_aboverrr#piv_rowpiv_col pivot_colsswaps pivot_offset pivot_valassumed_nonzeronewly_determinedoffsetvalrrr!rowpiv_ipiv_jr"sf&f&&&&&& @r_row_reduce_listr< sLJ?4 #< 0E!WJ E D.W^,B *J-B * i) .MVS g F),Ct g% &.   qLG '" 1  WlW4 5 LL'<'#9: ; U "qA!C$ O1T6A:>AE4<8s1v 12A9I;Cg~U"sW}c$h()C# Cg 6 1 )t"3%j1LE5E$J./I&)Cd U" #5:-1EAIt3CDs1v 12AE2 j!5< //rc \\V4VPVPVPWVWER7 wrgpVP VPVPV4Wx3#)r,r-r.)r<listr(rr)_new) Mr*r+r,r-r.rr1r2s &&&&&& r _row_reducerB|sU.d1gqvvqvvquu 8CU 66!&&!&&# & 99rczaVP^8:gVP^8:dR#\;QJd&V3RlVR,4F 'dK RM RM!V3RlVR,44pS!VR,4'dT;'d\VR,S4#T;'d\VR,S4#)zReturns `True` if the matrix is in echelon form. That is, all rows of zeros are at the bottom, and below each leading non-zero in a row are exclusively zeros.Tc34<"TF pS!V4xK R#5irr).0tr*s& r _is_echelon..s6XjmmXsF)rNNr)rr)NNNrI)rIrI)r(rall _is_echelon)rAr* zeros_belows&f rrLrLs  vv{affk#6QuX6###6QuX66K!D'@@{1U8Z@@  = =;qy*==rFc ~\V\4'dTM\p\WVRRRR7wrVpV'dWV3#V#)aBReturns a matrix row-equivalent to ``M`` that is in echelon form. Note that echelon form of a matrix is *not* unique, however, properties like the row space and the null space are preserved. Examples ======== >>> from sympy import Matrix >>> M = Matrix([[1, 2], [3, 4]]) >>> M.echelon_form() Matrix([ [1, 2], [0, -2]]) TFr>) isinstancerr rB)rAr*simplify with_pivotsr+rpivots_s&&&& r _echelon_formrTsC &h ==x9H 5UDNC{ Jrc nRp\V\4'dTM\pVP^8:gVP^8:d^#VP^8:gVP^8:d VUu.uF qQ!V4NK ppRV9d^#VP^8XdmVP^8Xd\VUu.uF qQ!V4NK ppRV9d RV9d^#VP 4pV!V4'd RV9d^#V!V4RJd^#V!WR7wr\ WVRRRR7wrp \V 4#uupiuupi)zReturns the rank of a matrix. Examples ======== >>> from sympy import Matrix >>> from sympy.abc import x >>> m = Matrix([[1, 2], [x, 1 - 1/x]]) >>> m.rank() 2 >>> n = Matrix(3, 3, range(1, 10)) >>> n.rank() 2 caaVV3Rlp\SP4Uu.uF q2!V4V3NK pp\V4UUu.uFwr5VNK pppSPVRR7V3#uupiuuppi)aPPermute columns with complicated elements as far right as they can go. Since the ``sympy`` row reduction algorithms start on the left, having complexity right-shifted speeds things up. Returns a tuple (mat, perm) where perm is a permutation of the columns to perform to shift the complex columns right, and mat is the permuted matrix.c@<\V3RlSRV3,44#)c3@<"TFpS!V4f^M^xK R#5irr)rEer*s& rrGO_rank.._permute_complexity_right..complexity..sJ'QJqM1qq8'srJ)sum)rrAr*s&r complexity<_rank.._permute_complexity_right..complexitysJ!AqD'JJ Jrr) orientation)rrsortedpermute)rAr*r\rcomplexrpermsff r_permute_complexity_right(_rank.._permute_complexity_rightsj K 05QVV}=}!JqM1%}=#)'?3?!1?3 $F 3T::>3s A( A-FN)r*Tr>)rOrr r(rdetrBlen) rAr*rPrcr+xzerosdrrSrRs &&& r_rankrjs ;(&h ==x9H  vv{affkvv{affk()*1A* E>vv{qvv{()*1A*  $e"3 EEG a==Ue^ a=E !,QFFCs/LAq v;-+ +s ,D--D2c\VR4'gR#VPpVPpVP'dV#VP'dVP \ 4#\;QJdRV4F 'dK RM RM !RV44'gR#VP \ 4# \dTu#i;i \dTP \4u#i;i)_repNc38"TFqPxK R#5ir) is_Rational)rErYs& rrG_to_DM_ZZ_QQ..s,!Q==!sFT) hasattrrldomainis_ZZis_QQ convert_torrrKr)rArepKs& r _to_DM_ZZ_QQrws 1f   &&C Awww  >>"% %s,!,sss,!,,, &>>"% %  J  &>>"% % &s$B;&C; C  C  C10C1c VPpVP'd.VPRR7wr#pVP4V, pM'VP'dVP 4wr$MQhVP 4pWT3#)z7Compute the reduced row echelon form of a DomainMatrix.F) keep_domain)rqrrrref_dento_fieldrsrref to_Matrix)dMrvdM_rrefdenrRM_rrefs& r_rref_dmrso Awww!{{u{=f""$s* '')u    F >rc \V4pVe\V4wrgM2\V\4'dTpM\p\ WVVRRR7wrgp V'dWg3#V#)aAReturn reduced row-echelon form of matrix and indices of pivot vars. Parameters ========== iszerofunc : Function A function used for detecting whether an element can act as a pivot. ``lambda x: x.is_zero`` is used by default. simplify : Function A function used to simplify elements when looking for a pivot. By default SymPy's ``simplify`` is used. pivots : True or False If ``True``, a tuple containing the row-reduced matrix and a tuple of pivot columns is returned. If ``False`` just the row-reduced matrix is returned. normalize_last : True or False If ``True``, no pivots are normalized to `1` until after all entries above and below each pivot are zeroed. This means the row reduction algorithm is fraction free until the very last step. If ``False``, the naive row reduction procedure is used where each pivot is normalized to be `1` before row operations are used to zero above and below the pivot. Examples ======== >>> from sympy import Matrix >>> from sympy.abc import x >>> m = Matrix([[1, 2], [x, 1 - 1/x]]) >>> m.rref() (Matrix([ [1, 0], [0, 1]]), (0, 1)) >>> rref_matrix, rref_pivots = m.rref() >>> rref_matrix Matrix([ [1, 0], [0, 1]]) >>> rref_pivots (0, 1) ``iszerofunc`` can correct rounding errors in matrices with float values. In the following example, calling ``rref()`` leads to floating point errors, incorrectly row reducing the matrix. ``iszerofunc= lambda x: abs(x) < 1e-9`` sets sufficiently small numbers to zero, avoiding this error. >>> m = Matrix([[0.9, -0.1, -0.2, 0], [-0.8, 0.9, -0.4, 0], [-0.1, -0.8, 0.6, 0]]) >>> m.rref() (Matrix([ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0]]), (0, 1, 2)) >>> m.rref(iszerofunc=lambda x:abs(x)<1e-9) (Matrix([ [1, 0, -0.301369863013699, 0], [0, 1, -0.712328767123288, 0], [0, 0, 0, 0]]), (0, 1)) Notes ===== The default value of ``normalize_last=True`` can provide significant speedup to row reduction, especially on matrices with symbols. However, if you depend on the form row reduction algorithm leaves entries of the matrix, set ``normalize_last=False`` T)r-r.)rwrrOrr rB) rAr*rPrRr,r~rr1r+rSs &&&&& r_rrefr'sfT aB ~"2,Z h - -H H($4A rN)TTT)typesrsympy.polys.polyerrorsrsympy.polys.domainsrr utilitiesrrr r determinantr r<rBrLrTrjrwrrrrrrse1&OO/n0d:& > !(%U8 %CL&<" %\r