U ;qLe< @sddlmZmZddlmZddlmZmZmZddl m Z m Z ddl m Z mZddlmZddlmZddlmZmZmZmZmZmZmZdd lmZdd lmZdd lm Z dd l!m"Z#d dl$m%Z%d dl&m'Z'd dl(m)Z)d dl*m*Z*d dl+m,Z,d dl-m.Z.m/Z/m0Z0m1Z1Gddde'e Z2e 3e e2fe2ddZ4ddZ5ddZ6ddZ7ddZ8d d!Z9d"d#Z:d$d%Z;d&d'Zd*d+Z?d,d-Z@e@ed<d.S)/)askQ) handlers_dict)BasicsympifyS)mulMul)NumberIntegerDummyadjoint)rm_idunpacktypedflattenexhaustdo_onenew)NonInvertibleMatrixError) MatrixBase)sympy_deprecation_warning)validate_matmul_integer)Inverse) MatrixExpr)MatPow transpose)PermutationMatrix) ZeroMatrixIdentityGenericIdentity OneMatrixcseZdZdZdZeZddddddZedd Z e d d Z d$d d Z ddZ ddZfddZddZddZddZddZddZddZd%d d!Zd"d#ZZS)&MatMula A product of matrix expressions Examples ======== >>> from sympy import MatMul, MatrixSymbol >>> A = MatrixSymbol('A', 5, 4) >>> B = MatrixSymbol('B', 4, 3) >>> C = MatrixSymbol('C', 3, 6) >>> MatMul(A, B, C) A*B*C TFN)evaluatecheck_sympifycs|s jSttfdd|}|r2ttt|}tjf|}|\}}|dk rdtdddd|dk rtt ||s||S|r |S|S)Ncs j|kSN)identity)iclsx/home/p21-0144/sympy/latex2sympy2solve-back-end/sympyEq/lib/python3.8/site-packages/sympy/matrices/expressions/matmul.py0z MatMul.__new__..zaPassing check to MatMul is deprecated and the check argument will be removed in a future version.z1.11z,remove-check-argument-from-matrix-operations)deprecated_since_versionactive_deprecations_targetF) r+listfiltermaprr__new__as_coeff_matricesrvalidate _evaluate)r.r'r(r)argsobjfactormatricesr/r-r0r8*s(  zMatMul.__new__cCst|Sr*) canonicalize)r.exprr/r/r0r;JszMatMul._evaluatecCs$dd|jD}|dj|djfS)NcSsg|]}|jr|qSr/ is_Matrix.0argr/r/r0 Psz MatMul.shape..r)r<rowscols)selfr?r/r/r0shapeNsz MatMul.shapec  snddlm}ddlm|\}}t|dkrD||d||fSdgt|ddgt|d}|d<|d<dd} |d| tdt|D]}t|<qt |ddD]\}} | j dd||<qfd d t |D}t |} t fd d |Drd }||| ftdddgt||} t dd |Ds\d}|rj| S| S)Nr)SumImmutableMatrixrrHcss d}td|V|d7}qdS)Nrzi_%ir )counterr/r/r0fbszMatMul._entry..fdummy_generatorcs,g|]$\}}|j||ddqS)r)rR)_entryrEr,rF)rRindicesr/r0rGosz!MatMul._entry..c3s|]}|VqdSr*hasrEvrNr/r0 qsz MatMul._entry..Tcss|]}t|ttfVqdSr*) isinstancer intrXr/r/r0rZysF)sympy.concrete.summationsrMsympy.matrices.immutablerOr9lengetrangenext enumeraterLr fromiteranyzipdoit) rKr,jexpandkwargsrMcoeffr?Z ind_rangesrQrFZ expr_in_sumresultr/)rOrRrUr0rSSs6     z MatMul._entrycCsBdd|jD}dd|jD}t|}|jdkr:td||fS)NcSsg|]}|js|qSr/rBrExr/r/r0rG~sz,MatMul.as_coeff_matrices..cSsg|]}|jr|qSr/rBrmr/r/r0rGsFz3noncommutative scalars in MatMul are not supported.)r<r is_commutativeNotImplementedError)rKZscalarsr?rkr/r/r0r9}s  zMatMul.as_coeff_matricescCs|\}}|t|fSr*)r9r&rKrkr?r/r/r0 as_coeff_mmuls zMatMul.as_coeff_mmulc stt|jf|}||Sr*)superr&rir;)rKrjexpanded __class__r/r0risz MatMul.expandcCs2|\}}t|fdd|dddDS)aTransposition of matrix multiplication. Notes ===== The following rules are applied. Transposition for matrix multiplied with another matrix: `\left(A B\right)^{T} = B^{T} A^{T}` Transposition for matrix multiplied with scalar: `\left(c A\right)^{T} = c A^{T}` References ========== .. [1] https://en.wikipedia.org/wiki/Transpose cSsg|] }t|qSr/rrDr/r/r0rGsz*MatMul._eval_transpose..NrH)r9r&rgrqr/r/r0_eval_transposes  zMatMul._eval_transposecCs"tdd|jdddDS)NcSsg|] }t|qSr/rrDr/r/r0rGsz(MatMul._eval_adjoint..rH)r&r<rgrKr/r/r0 _eval_adjointszMatMul._eval_adjointcCs<|\}}|dkr0ddlm}|||StddS)Nr)tracezCan't simplify any further)rrrzrgrp)rKr>mmulrzr/r/r0 _eval_traces   zMatMul._eval_tracecCs<ddlm}|\}}t|}||jttt||S)Nr) Determinant)&sympy.matrices.expressions.determinantr}r9 only_squaresrIr r5r7)rKr}r>r?Zsquare_matricesr/r/r0_eval_determinants  zMatMul._eval_determinantcCs>tdd|jDr6tdd|jdddDSt|S)Ncss|]}t|tr|jVqdSr*)r[r is_squarerDr/r/r0rZs z'MatMul._eval_inverse..css(|] }t|tr|n|dVqdS)rHN)r[rinverserDr/r/r0rZsrH)allr<r&rgrrxr/r/r0 _eval_inverses  zMatMul._eval_inversec s@dd}|r*tfdd|jD}n|j}tt|}|S)NdeepTc3s|]}|jfVqdSr*)rgrDhintsr/r0rZszMatMul.doit..)r`tupler<r@r&)rKrrr<rAr/rr0rgs   z MatMul.doitc sjddjD}ddjD}|rbt|}t|}|rb|rbt||krbtdfdd|D||gS)NcSsg|]}|jr|qSr/rormr/r/r0rGsz#MatMul.args_cnc..cSsg|]}|js|qSr/rrmr/r/r0rGsz"repeated commutative arguments: %scs$g|]}tj|dkr|qSr)r5r<count)rEcirxr/r0rGs)r<r_set ValueError)rKcsetwarnrjZcoeff_cZcoeff_ncclenr/rxr0args_cncszMatMul.args_cncc sddlmfddt|jD}g}|D]}|jd|}|j|dd}|r`t|}nt|jd}|rtfddt|D}nt|jd}|j| } | D]"} | || || | qq,|S)Nr Transposecsg|]\}}|r|qSr/rVrTrnr/r0rGs z8MatMul._eval_derivative_matrix_lines..cs"g|]}|jr|n|qSr/)rCrg)rEr,rr/r0rGsr) r rrcr<r&rdr#rLreversed_eval_derivative_matrix_lines append_first append_secondappend) rKrnZ with_x_indlinesindZ left_argsZ right_argsZ right_matZleft_revdr,r/)rrnr0rs$    z$MatMul._eval_derivative_matrix_lines)T)FT)__name__ __module__ __qualname____doc__ is_MatMulr$r+r8 classmethodr;propertyrLrSr9rrrirwryr|rrrgrr __classcell__r/r/rur0r&s(     *    r&cGs&|ddkr|dd}ttf|S)Nrr)rr&r<r/r/r0newmuls  rcCs>tdd|jDr:dd|jD}t|dj|djS|S)Ncss |]}|jp|jo|jVqdSr*)is_zerorC is_ZeroMatrixrDr/r/r0rZszany_zeros..cSsg|]}|jr|qSr/rBrDr/r/r0rGszany_zeros..rrH)rer<r"rIrJ)rr?r/r/r0 any_zeross rcCstdd|jDs|Sg}|jd}|jddD]8}t|ttfr^t|ttfr^||}q4|||}q4||t|S)a Merge explicit MatrixBase arguments >>> from sympy import MatrixSymbol, Matrix, MatMul, pprint >>> from sympy.matrices.expressions.matmul import merge_explicit >>> A = MatrixSymbol('A', 2, 2) >>> B = Matrix([[1, 1], [1, 1]]) >>> C = Matrix([[1, 2], [3, 4]]) >>> X = MatMul(A, B, C) >>> pprint(X) [1 1] [1 2] A*[ ]*[ ] [1 1] [3 4] >>> pprint(merge_explicit(X)) [4 6] A*[ ] [4 6] >>> X = MatMul(B, A, C) >>> pprint(X) [1 1] [1 2] [ ]*A*[ ] [1 1] [3 4] >>> pprint(merge_explicit(X)) [1 1] [1 2] [ ]*A*[ ] [1 1] [3 4] css|]}t|tVqdSr*)r[rrDr/r/r0rZsz!merge_explicit..rrN)rer<r[rr rr&)matmulnewargslastrFr/r/r0merge_explicits    rcCs<|\}}tdd|}||kr4t|f|jS|SdS)z Remove Identities from a MatMul This is a modified version of sympy.strategies.rm_id. This is necesssary because MatMul may contain both MatrixExprs and Exprs as args. See Also ======== sympy.strategies.rm_id cSs |jdkS)NT) is_Identityrr/r/r0r18r2zremove_ids..N)rrrrr<)rr>r{rlr/r/r0 remove_ids)s rcCs&|\}}|dkr"t|f|S|SNr)r9r)rr>r?r/r/r0factor_in_front>s rc Cs(|\}}|dg}tdt|D]}|d}||}t|trt|jtr|jj}t|}t||| dkr|d| t |j dg}q$t|trt|jtr|jj} t| }t| ||||krt |j d} | |d<t|||D] } | || <qq$|j dks&|j dkr2| |q$t|t rJ|j\} } n |tj} } t|t rn|j\}}n |tj}}| |kr| |}t | |jdd|d<q$nht|tsz |}Wntk rd}YnX|dk r| |kr| |}t | |jdd|d<q$| |q$t|f|S)aCombine consecutive powers with the same base into one, e.g. $$A \times A^2 \Rightarrow A^3$$ This also cancels out the possible matrix inverses using the knowledgebase of :class:`~.Inverse`, e.g., $$ Y \times X \times X^{-1} \Rightarrow Y $$ rrrHNF)r)r9rar_r[rrFr&r<r5r#rLrrrrOnergrrrr)rr>r<new_argsr,ABZBargslZAargsr+rhZA_baseZA_expZB_baseZB_expnew_expZ B_base_invr/r/r0combine_powersDsX               rc Cs|j}t|}|dkr|S|dg}td|D]X}|d}||}t|tr|t|tr||jd}|jd}t|||d<q.||q.t|S)zGRefine products of permutation matrices as the products of cycles. rrrH)r<r_rar[r!rr&) rr<rrlr,rrZcycle_1Zcycle_2r/r/r0combine_permutationss      rcCs|\}}|dg}|ddD]^}|d}t|trBt|tsN||q"||t|jd|jd||jd9}q"t|f|S)zj Combine products of OneMatrix e.g. OneMatrix(2, 3) * OneMatrix(3, 4) -> 3 * OneMatrix(2, 4) rrNrH)r9r[r%rpoprLr)rr>r<rrrr/r/r0combine_one_matricess   rcs|jtdkr~ddlm}djrNdjrN|fdddjDSdjr~djr~|fdddjDS|S)zr Simplify MatMul expressions but distributing rational term to MatMul. e.g. 2*(A+B) -> 2*A + 2*B rr)MatAddrcsg|]}t|dqSrr&rgrEmatrr/r0rGsz$distribute_monom..csg|]}td|qS)rrrrr/r0rGs)r<r_mataddr is_MatAdd is_Rational)rrr/rr0distribute_monoms  rcCs|dkSrr/rr/r/r0r1r2r1cGsp|dj|djkrtdg}d}t|D]>\}}|j||jkr,|t|||d|d}q,|S)z'factor matrices only if they are squarerrHz!Invalid matrices being multipliedr)rIrJ RuntimeErrorrcrr&rg)r?outstartr,Mr/r/r0rs rcCsg}g}|jD] }|jr$||q||q|d}|ddD]h}||jkrrtt||rrt|jd}qD|| krtt ||rt|jd}qD|||}qD||t |S)z >>> from sympy import MatrixSymbol, Q, assuming, refine >>> X = MatrixSymbol('X', 2, 2) >>> expr = X * X.T >>> print(expr) X*X.T >>> with assuming(Q.orthogonal(X)): ... print(refine(expr)) I rrN) r<rCrTrr orthogonalr#rL conjugateunitaryr&)rA assumptionsrZexprargsr<rrFr/r/r0 refine_MatMuls      rN)Asympy.assumptions.askrrsympy.assumptions.refiner sympy.corerrrZsympy.core.mulrr sympy.core.numbersr r sympy.core.symbolr sympy.functionsrsympy.strategiesrrrrrrrsympy.matrices.commonrsympy.matrices.matricesrsympy.utilities.exceptionsrZ!sympy.matrices.expressions._shaperr:rrmatexprrmatpowrr permutationr!specialr"r#r$r%r&register_handlerclassrrrrrrrrrrulesr@rrr/r/r/r0sZ   $         X*?  "