g0ddlmZddlmZddlmZmZddlmZm Z m Z m Z ddl m Z  ddZ dd Ze fd Ze d d fd Ze d fd ZdZdZe d ddfdZdS)) FunctionType)CoercionFailed)ZZQQ)_get_intermediate_simp_iszero _dotprodsimp _simplify)_find_reasonable_pivotTc fd} fd} fd} ttd\} } g}g}| kr>| |kr7t| | | d||\}}}}|D]\}}|| z }||z| z<|| dz } U|| |dkr)| | || z|| || zf|durJ| | }}||z|z<t |z|zdz|dzzD]}||z |<|}t |D]<}|| kr |dur|| kr|z| z}||r.| |||| =| dz } | kr| |k7|d urk|d urgt |D]W\}}|z|z}||z|z<t |z|zdz|dzzD]}||z |<Xt |t |fS) aRow 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|dSN)icolsmats U/var/www/html/ai-engine/env/lib/python3.11/site-packages/sympy/matrices/reductions.pyget_colz!_row_reduce_list..get_col/s17d7|c|z|dzz|z|dzzc|z|dzz<|z|dzz<dS)Nrr)rjrrs rrow_swapz"_row_reduce_list..row_swap2so $At|# $c!D&!a%*=&> ;AdFAE4<  #afa!eT\&9":":":rc||z z}t|z|dzzD](}||z|||zzz |<)dS)z,Does the row op row[i] = a*row[i] - b*row[j]rN)range) arbrqprisimprs r cross_cancelz&_row_reduce_list..cross_cancel6sm UDLqvAt|,, 4 4AU1SV8aAE l233CFF 4 4rrrNrrFT)rr r appendr enumeratetuple)rrowsrone iszerofuncsimpfuncnormalize_last normalize zero_aboverrr!piv_rowpiv_col pivot_colsswaps pivot_offset pivot_valassumed_nonzeronewly_determinedoffsetvalrrrrowpiv_ipiv_jr s` ` @r_row_reduce_listr: sAJ??????4444444 #< 0 0EGWJ E D..Wt^^,B  *J-B-B * i) . - -MVS g F),Ct g% & &   qLG '""" 1   HWlW4 5 5 5 LL'<'#9: ; ; ; U " "GqA!C$ O1T6A:>AE4<88 3 3s1v 122AI;; 7 7Cg~~U""sW}}c$h()Cz#  LCg 6 6 6 61 Y D..Wt^^^)t"3"3%j11 3 3LE5E$J./I&)Cd U" #5:-1EAIt3CDD 3 3s1v 122A 3 j!!5<< //rc tt||j|j|j||||| \}}}||j|j|||fS)Nr*r+r,)r:listr&rr'_new) Mr(r)r*r+r,rr/r0s r _row_reducer@|sb.d1ggqvqvqu J888CU 66!&!&# & & E 99rc|jdks |jdkrdStfd|dddfD}|dr|ot|ddddfS|ot|ddddfS)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.rTc3.K|]}|VdSrr).0tr(s r z_is_echelon..s+66jjmm666666rrNr")r&rall _is_echelon)r?r( zeros_belows ` rrGrGs  v{{afkkt6666Qqrr1uX66666Kz!D'A@{1QQQU8Z@@@  =;qQRRy*===rFct|tr|nt}t|||ddd\}}}|r||fS|S)anReturns 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 r@)r?r(simplify with_pivotsr)rpivots_s r _echelon_formrOs_ &h ==Lxx9H J5UDDDNCF{ Jrcd}t|tr|nt}|jdks |jdkrdS|jdks |jdkrfd|D}d|vrdS|jdkrW|jdkrLfd|D}d|vrd|vrdS|}|rd|vrdS|durdS|| \}}t ||d dd \}} }t| S) 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 cfdfdtjD}dt|D}|d|fS)aPermute 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.cNtfddd|fDS)Nc36K|]}|dndVdS)Nrrr)rCer(s rrEzO_rank.._permute_complexity_right..complexity..s4JJQJJqMM1qqqJJJJJJr)sum)rr?r(s r complexityz<_rank.._permute_complexity_right..complexitys4JJJJ!AAAqD'JJJJJ Jrc*g|]}||fSrr)rCrrVs r z<_rank.._permute_complexity_right..s&===!JJqMM1%===rcg|]\}}|Srr)rCrrs rrXz<_rank.._permute_complexity_right..s333!Q1333rr) orientation)rrsortedpermute)r?r(complexpermrVs`` @r_permute_complexity_rightz(_rank.._permute_complexity_rights K K K K K K >===uQV}}===336'??333 $F 33T::rrrc&g|] }|SrrrCxr(s rrXz_rank..!***1A***rFc&g|] }|Srrras rrXz_rank..rcrN)r(Tr<)rJrr r&rdetr@len) r?r(rKr_r)zerosdrrNrMs ` r_rankrjs\ ;;;(&h ==Lxx9H  v{{afkkqv{{afkk******* E>>1v{{qv{{*******   $e"3"31 EEGG :a== Ue^^1 :a==E ! !1,,Q:FFFFCsJ///LAvq v;;rc|t|dsdS|j}|j}|jr|S|jr- |t S#t$r|cYSwxYwtd|DsdS |t S#t$r|tcYSwxYw)N_repc3$K|] }|jV dSr) is_Rational)rCrTs rrEz_to_DM_ZZ_QQ..s$,,Q1=,,,,,,r) hasattrrldomainis_ZZis_QQ convert_torrrFr)r?repKs r _to_DM_ZZ_QQrvs 1f  t &C Aw &  & >>"%% %   JJJ ,,!,,,,, 4 &>>"%% % & & &>>"%% % % % &s#A AA:B$B;:B;c|j}|jr2|d\}}}||z }n!|jr|\}}nJ|}||fS)z7Compute the reduced row echelon form of a DomainMatrix.F) keep_domain)rprqrref_dento_fieldrrrref to_Matrix)dMrudM_rrefdenrMM_rrefs r_rref_dmrs Aw!{{u{==f""$$s* ''))    F 6>rct|}|t|\}}n8t|tr|}nt}t ||||dd\}}} |r||fS|S)a- Return 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`` NT)r+r,)rvrrJrr r@) r?r(rKrMr*r}rr/r)rNs r_rrefr'sT aB ~"2,,ZZ h - - !HH H(J$4AAAZJ rN)TTT)typesrsympy.polys.polyerrorsrsympy.polys.domainsrr utilitiesrr r r determinantr r:r@rGrOrjrvrrrrrrsW111111&&&&&&&&OOOOOOOOOOOO//////AEn0n0n0n0d9=+/::::& > > > > !(%U8 %CCCCL&&&<" %\\\\\\r