U @f0@sddlmZddlmZddlmZmZddlmZm Z m Z m Z ddl m Z ddd Zdd d Ze fd d Ze ddfddZe dfddZddZddZe dddfddZdS)) FunctionType)CoercionFailed)ZZQQ)_get_intermediate_simp_iszero _dotprodsimp _simplify)_find_reasonable_pivotTc sDfdd} fdd} fdd} ttd\} } g}g}| kr| |krt| | | d||\}}}}|D] \}}|| 7}||| <q||dkr| d 7} qD|| |d kr| | || || || f|d krD| | }}|||<t||d |d D]}|||<q$|}t|D]X}|| kr^qL|d krv|| krvqL|| }||rqL| |||| qL| d 7} qD|d kr2|d kr2t|D]d\}}||}|||<t||d |d D]}|||<qq̈t|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. cs|dSNicolsmatr =/tmp/pip-unpacked-wheel-6uje5nh9/sympy/matrices/reductions.pyget_col/sz!_row_reduce_list..get_colcs^||d||d||d<||d<dS)Nrr )rjrr rrow_swap2s.z"_row_reduce_list..row_swapcsP||}t||dD](}||||||<q"dS)z,Does the row op row[i] = a*row[i] - b*row[j]rN)range)arbrqprZisimprr r cross_cancel6s z&_row_reduce_list..cross_cancelrrNrrFT)rr r appendr enumeratetuple)rrowsrone iszerofuncsimpfuncnormalize_last normalize zero_aboverrrZpiv_rowZpiv_col pivot_colsswapsZ pivot_offsetZ pivot_valZassumed_nonzeroZnewly_determinedoffsetvalrrrrowZpiv_iZpiv_jr rr_row_reduce_list sb%    "    "r.c CsBtt||j|j|j|||||d \}}}||j|j|||fS)Nr&r'r()r.listr"rr#Z_new) Mr$r%r&r'r(rr)r*r r r _row_reduce|s r2cs|jdks|jdkrdStfdd|dddfD}|drd|obt|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.rTc3s|]}|VqdSr r ).0tr$r r sz_is_echelon..rNr)r"rall _is_echelon)r1r$Z zeros_belowr r5rr8s " r8FcCs<t|tr|nt}t|||dddd\}}}|r8||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 r2)r1r$simplifyZ with_pivotsr%rpivots_r r r _echelon_forms r=c sdd}t|tr|nt}|jdks.|jdkr2dS|jdksF|jdkrdfdd|D}d|krddS|jdkr|jdkrʇfd d|D}d|krd |krdS|}|rd|krdS|dkrdS||d \}}t||d ddd \}} }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 csJfddfddtjD}ddt|D}j|dd|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.cs"tfdddd|fDS)Nc3s"|]}|dkrdndVqdS)Nrrr r3er5r rr6szO_rank.._permute_complexity_right..complexity..)sumr)r1r$r r complexitysz<_rank.._permute_complexity_right..complexitycsg|]}||fqSr r )r3r)rAr r sz<_rank.._permute_complexity_right..cSsg|] \}}|qSr r )r3rrr r rrBsr)Z orientation)rrsortedZpermute)r1r$complexpermr )r1rAr$r_permute_complexity_rights z(_rank.._permute_complexity_rightrrcsg|] }|qSr r r3xr5r rrBsz_rank..Fcsg|] }|qSr r rGr5r rrBsNr5Tr/)r9rr r"rZdetr2len) r1r$r:rFr%zerosdrr<r;r r5r_ranks.   rMcCst|dsdS|j}|j}|jr$|S|jrRz |tWStk rN|YSXnBtdd|DshdSz |tWStk r|t YSXdS)N_repcss|] }|jVqdSr )Z is_Rationalr>r r rr6sz_to_DM_ZZ_QQ..) hasattrrNdomainis_ZZis_QQZ convert_torrr7r)r1repKr r r _to_DM_ZZ_QQs"    rUcCsX|j}|jr,|jdd\}}}||}n|jr@|\}}ndsHt|}||fS)z7Compute the reduced row echelon form of a DomainMatrix.F)Z keep_domain)rPrQZrref_denZto_fieldrRZrrefAssertionErrorZ to_Matrix)dMrTZdM_rrefZdenr;ZM_rrefr r r_rref_dmsrXc Cs`t|}|dk rt|\}}n.t|tr.|}nt}t||||ddd\}}} |rX||fS|SdS)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()rUrXr9rr r2) r1r$r:r;r&rWrr)r%r<r r r_rref'sJ  rYN)TTT)TTT)typesrZsympy.polys.polyerrorsrZsympy.polys.domainsrrZ utilitiesrrr r Z determinantr r.r2r8r=rMrUrXrYr r r rs(    r F