o
    "ôj•<  ã                   @   sÌ  d dl mZmZ d dlmZ d dlmZmZmZ d dl	m
Z
mZ d dlmZmZ d dlmZ d dlmZ d dlmZmZmZmZmZmZmZ d d	lmZ d d
lmZ d dlm Z  d dl!m"Z# ddl$m%Z% ddl&m'Z' ddl(m)Z) ddl*m*Z* ddl+m,Z, ddl-m.Z.m/Z/m0Z0m1Z1 G dd„ de'eƒZ2e
 3ee2fe2¡ dd„ Z4dd„ Z5dd„ Z6dd„ Z7dd„ Z8d d!„ Z9d"d#„ Z:d$d%„ Z;d&d'„ Z<e<e5e7e;e9eed(d)„ ƒe6e8ee:fZ=eee2ee=Ž iƒƒZ>d*d+„ Z?d,d-„ Z@e@ed< d.S )/é    )ÚaskÚQ)Úhandlers_dict)ÚBasicÚsympifyÚS)ÚmulÚMul)ÚNumberÚInteger©ÚDummy©Úadjoint)Úrm_idÚunpackÚtypedÚflattenÚexhaustÚdo_oneÚnew)ÚNonInvertibleMatrixError)Ú
MatrixBase)Úsympy_deprecation_warning)Úvalidate_matmul_integeré   )ÚInverse)Ú
MatrixExpr)ÚMatPow©Ú	transpose)ÚPermutationMatrix)Ú
ZeroMatrixÚIdentityÚGenericIdentityÚ	OneMatrixc                       s°   e Zd ZdZdZeƒ Zddddœdd„Zedd	„ ƒZ	e
d
d„ ƒZd$dd„Zdd„ Zdd„ Z‡ fdd„Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zd%d d!„Zd"d#„ Z‡  ZS )&Ú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)ÚevaluateÚcheckÚ_sympifyc                   s�   |sˆ j S tt‡ fdd„|ƒƒ}|rttt|ƒƒ}tjˆ g|¢R Ž }| ¡ \}}|d ur3tdddd� |dur;t	|Ž  |s?|S |rFˆ  
|¡S |S )Nc                    s
   ˆ j | kS ©N)Úidentity)Úi©Úcls© út/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/sympy/matrices/expressions/matmul.pyÚ<lambda>0   ó   
 z MatMul.__new__.<locals>.<lambda>zaPassing check to MatMul is deprecated and the check argument will be removed in a future version.z1.11z,remove-check-argument-from-matrix-operations)Údeprecated_since_versionÚactive_deprecations_targetF)r+   ÚlistÚfilterÚmapr   r   Ú__new__Úas_coeff_matricesr   ÚvalidateÚ	_evaluate)r.   r'   r(   r)   ÚargsÚobjÚfactorÚmatricesr/   r-   r0   r8   *   s(   ý
zMatMul.__new__c                 C   s   t |ƒS r*   )Úcanonicalize)r.   Úexprr/   r/   r0   r;   J   s   zMatMul._evaluatec                 C   s$   dd„ | j D ƒ}|d j|d jfS )Nc                 S   ó   g | ]}|j r|‘qS r/   ©Ú	is_Matrix©Ú.0Úargr/   r/   r0   Ú
<listcomp>P   ó    z MatMul.shape.<locals>.<listcomp>r   éÿÿÿÿ)r<   ÚrowsÚcols)Úselfr?   r/   r/   r0   ÚshapeN   s   zMatMul.shapec                    sj  ddl m} ddlm‰  |  ¡ \}}t|ƒdkr"||d ||f  S d gt|ƒd  ‰d gt|ƒd  }|ˆd< |ˆd< dd„ }	| d|	ƒ ¡‰tdt|ƒƒD ]}tˆƒˆ|< qNt	|d d… ƒD ]\}}
|
j
d d ||< q_‡‡fd	d
„t	|ƒD ƒ}t |¡}t‡ fdd„|D ƒƒr‹d}|||gtˆdd… dgt|ƒ |ƒ¢R Ž  }tdd„ |D ƒƒs­d}|r³| ¡ S |S )Nr   )ÚSum©ÚImmutableMatrixr   rJ   c                  s   s    � d} 	 t d|  ƒV  | d7 } q)Nr   Tzi_%ir   )Úcounterr/   r/   r0   Úfb   s   €þzMatMul._entry.<locals>.fÚdummy_generatorc                    s,   g | ]\}}|j ˆ| ˆ|d   ˆ d�‘qS )r   )rT   )Ú_entry©rF   r,   rG   )rT   Úindicesr/   r0   rH   o   s   , z!MatMul._entry.<locals>.<listcomp>c                 3   s   � | ]}|  ˆ ¡V  qd S r*   ©Úhas©rF   ÚvrP   r/   r0   Ú	<genexpr>q   ó   € z MatMul._entry.<locals>.<genexpr>Tc                 s   s   � | ]
}t |ttfƒV  qd S r*   )Ú
isinstancer   ÚintrZ   r/   r/   r0   r\   y   s   € F)Úsympy.concrete.summationsrO   Úsympy.matrices.immutablerQ   r9   ÚlenÚgetÚrangeÚnextÚ	enumeraterN   r	   ÚfromiterÚanyÚzipÚdoit)rM   r,   ÚjÚexpandÚkwargsrO   Úcoeffr?   Z
ind_rangesrS   rG   Zexpr_in_sumÚresultr/   )rQ   rT   rW   r0   rU   S   s6   
ÿ
þzMatMul._entryc                 C   sB   dd„ | j D ƒ}dd„ | j D ƒ}t|Ž }|jdu rtdƒ‚||fS )Nc                 S   ó   g | ]}|j s|‘qS r/   rC   ©rF   Úxr/   r/   r0   rH   ~   rI   z,MatMul.as_coeff_matrices.<locals>.<listcomp>c                 S   rB   r/   rC   rq   r/   r/   r0   rH      rI   Fz3noncommutative scalars in MatMul are not supported.)r<   r	   Úis_commutativeÚNotImplementedError)rM   Úscalarsr?   rn   r/   r/   r0   r9   }   s   
zMatMul.as_coeff_matricesc                 C   s   |   ¡ \}}|t|Ž fS r*   )r9   r&   ©rM   rn   r?   r/   r/   r0   Úas_coeff_mmul†   s   zMatMul.as_coeff_mmulc                    s    t t| ƒjdi |¤Ž}|  |¡S ©Nr/   )Úsuperr&   rl   r;   )rM   rm   Úexpanded©Ú	__class__r/   r0   rl   Š   s   
zMatMul.expandc                 C   s4   |   ¡ \}}t|gdd„ |ddd… D ƒ¢R Ž  ¡ S )a¨  Transposition 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
        c                 S   ó   g | ]}t |ƒ‘qS r/   r   rE   r/   r/   r0   rH   £   ó    z*MatMul._eval_transpose.<locals>.<listcomp>NrJ   )r9   r&   rj   rv   r/   r/   r0   Ú_eval_transposeŽ   s   ÿÿÿzMatMul._eval_transposec                 C   s"   t dd„ | jd d d… D ƒŽ  ¡ S )Nc                 S   r}   r/   r   rE   r/   r/   r0   rH   ¦   r~   z(MatMul._eval_adjoint.<locals>.<listcomp>rJ   )r&   r<   rj   ©rM   r/   r/   r0   Ú_eval_adjoint¥   s   "zMatMul._eval_adjointc                 C   s4   |   ¡ \}}|dkrddlm} ||| ¡ ƒ S d S )Nr   )Útrace)rw   r‚   rj   )rM   r>   Úmmulr‚   r/   r/   r0   Ú_eval_trace¨   s
   þzMatMul._eval_tracec                 C   s<   ddl m} |  ¡ \}}t|Ž }|| j ttt||ƒƒŽ  S )Nr   )ÚDeterminant)Ú&sympy.matrices.expressions.determinantr…   r9   Úonly_squaresrK   r	   r5   r7   )rM   r…   r>   r?   Zsquare_matricesr/   r/   r0   Ú_eval_determinant®   s   zMatMul._eval_determinantc                 C   s>   t dd„ | jD ƒƒrtdd„ | jd d d… D ƒŽ  ¡ S t| ƒS )Nc                 s   s    � | ]}t |tƒr|jV  qd S r*   )r^   r   Ú	is_squarerE   r/   r/   r0   r\   µ   ó   € z'MatMul._eval_inverse.<locals>.<genexpr>c                 s   s*   � | ]}t |tƒr| ¡ n|d  V  qdS )rJ   N)r^   r   ÚinverserE   r/   r/   r0   r\   ¶   s
   € ÿ
ÿrJ   )Úallr<   r&   rj   r   r€   r/   r/   r0   Ú_eval_inverse´   s   þüzMatMul._eval_inversec                    s@   ˆ   dd¡}|rt‡ fdd„| jD ƒƒ}n| j}tt|Ž ƒ}|S )NÚdeepTc                 3   s    � | ]}|j di ˆ ¤ŽV  qd S rx   )rj   rE   ©Úhintsr/   r0   r\   À   rŠ   zMatMul.doit.<locals>.<genexpr>)rc   Útupler<   r@   r&   )rM   r�   rŽ   r<   rA   r/   r�   r0   rj   ½   s   zMatMul.doitc                    sj   dd„ ˆ j D ƒ}dd„ ˆ j D ƒ}|r1t|ƒ}t|ƒ}|r1|r1t|ƒ|kr1td‡ fdd„|D ƒ ƒ‚||gS )Nc                 S   rB   r/   ©rs   rq   r/   r/   r0   rH   Ê   rI   z#MatMul.args_cnc.<locals>.<listcomp>c                 S   rp   r/   r’   rq   r/   r/   r0   rH   Ë   rI   z"repeated commutative arguments: %sc                    s$   g | ]}t ˆ jƒ |¡d kr|‘qS ©r   )r5   r<   Úcount)rF   Úcir€   r/   r0   rH   Ñ   s   $ )r<   rb   ÚsetÚ
ValueError)rM   ÚcsetÚwarnrm   Zcoeff_cZcoeff_ncÚclenr/   r€   r0   Úargs_cncÉ   s   ÿzMatMul.args_cncc                    sÜ   ddl m‰  ‡fdd„t| jƒD ƒ}g }|D ]U}| jd |… }| j|d d … }|r0t |¡}nt| jd ƒ}|rHt ‡ fdd„t|ƒD ƒ¡}nt| jd ƒ}| j|  	ˆ¡}	|	D ]}
|
 
|¡ |
 |¡ | |
¡ qYq|S )Nr   ©Ú	Transposec                    s   g | ]\}}|  ˆ ¡r|‘qS r/   rX   rV   ©rr   r/   r0   rH   Ö   ó    z8MatMul._eval_derivative_matrix_lines.<locals>.<listcomp>c                    s"   g | ]}|j rˆ |ƒ ¡ n|‘qS r/   )rD   rj   )rF   r,   rœ   r/   r0   rH   á   s   " r   )r    r�   rf   r<   r&   rg   r#   rN   ÚreversedÚ_eval_derivative_matrix_linesÚappend_firstÚappend_secondÚappend)rM   rr   Z
with_x_indÚlinesÚindZ	left_argsZ
right_argsZ	right_matZleft_revÚdr,   r/   )r�   rr   r0   r¡   Ô   s&   

ýz$MatMul._eval_derivative_matrix_lines)T)FT)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú	is_MatMulr$   r+   r8   Úclassmethodr;   ÚpropertyrN   rU   r9   rw   rl   r   r�   r„   rˆ   r�   rj   r›   r¡   Ú__classcell__r/   r/   r{   r0   r&      s*     


*		
r&   c                  G   s(   | d dkr| dd … } t tg| ¢R Ž S )Nr   r   )r   r&   ©r<   r/   r/   r0   Únewmulñ   s   r±   c                 C   s>   t dd„ | jD ƒƒrdd„ | jD ƒ}t|d j|d jƒS | S )Nc                 s   s"   � | ]}|j p|jo|jV  qd S r*   )Úis_zerorD   Úis_ZeroMatrixrE   r/   r/   r0   r\   ÷   s   € ÿzany_zeros.<locals>.<genexpr>c                 S   rB   r/   rC   rE   r/   r/   r0   rH   ù   rI   zany_zeros.<locals>.<listcomp>r   rJ   )rh   r<   r"   rK   rL   )r   r?   r/   r/   r0   Ú	any_zerosö   s   ÿr´   c                 C   s€   t dd„ | jD ƒƒs| S g }| jd }| jdd… D ]}t|ttfƒr/t|ttfƒr/|| }q| |¡ |}q| |¡ 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]
    c                 s   s   � | ]}t |tƒV  qd S r*   )r^   r   rE   r/   r/   r0   r\     r]   z!merge_explicit.<locals>.<genexpr>r   r   N)rh   r<   r^   r   r
   r¤   r&   )ÚmatmulÚnewargsÚlastrG   r/   r/   r0   Úmerge_explicitý   s   



r¸   c                 C   s:   |   ¡ \}}tdd„ ƒ|ƒ}||krt|g|j¢R Ž S | S )zð Remove Identities from a MatMul

    This is a modified version of sympy.strategies.rm_id.
    This is necessary because MatMul may contain both MatrixExprs and Exprs
    as args.

    See Also
    ========

    sympy.strategies.rm_id
    c                 S   s
   | j du S )NT)Úis_Identityrž   r/   r/   r0   r1   6  r2   zremove_ids.<locals>.<lambda>)rw   r   r±   r<   )r   r>   rƒ   ro   r/   r/   r0   Ú
remove_ids'  s
   rº   c                 C   s(   |   ¡ \}}|dkrt|g|¢R Ž S | S ©Nr   )r9   r±   )r   r>   r?   r/   r/   r0   Úfactor_in_front<  s   r¼   c              	   C   s  |   ¡ \}}|d g}tdt|ƒƒD ]ë}|d }|| }t|tƒrJt|jtƒrJ|jj}t|ƒ}t|ƒ|| d… krJ|d| … t	|j
d ƒg }qt|tƒrƒt|jtƒrƒ|jj}	t|	ƒ}t|	ƒ|||| … krƒt	|j
d ƒ}
|
|d< t||| ƒD ]}|
||< q{q|jdks�|jdkr“| |¡ qt|tƒrž|j\}}n|tj}}t|tƒr¯|j\}}n|tj}}||krÉ|| }t||ƒjdd�|d< qt|tƒsøz| ¡ }W n tyß   d}Y nw |durø||krø|| }t||ƒjdd�|d< q| |¡ qt|g|¢R Ž S )a  Combine 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 $$
    r   r   rJ   NF)rŽ   )r9   rd   rb   r^   r   rG   r&   r<   r5   r#   rN   r‰   r¤   r   r   ÚOnerj   r   r‹   r   r±   )r   r>   r<   Únew_argsr,   ÚAÚBZBargsÚlZAargsr+   rk   ZA_baseZA_expZB_baseZB_expÚnew_expZ
B_base_invr/   r/   r0   Úcombine_powersB  sZ   





ÿrÃ   c           	      C   s�   | j }t|ƒ}|dk r| S |d g}td|ƒD ],}|d }|| }t|tƒr>t|tƒr>|j d }|j d }t|| ƒ|d< q| |¡ qt|Ž S )zGRefine products of permutation matrices as the products of cycles.
    é   r   r   rJ   )r<   rb   rd   r^   r!   r¤   r&   )	r   r<   rÁ   ro   r,   r¿   rÀ   Zcycle_1Zcycle_2r/   r/   r0   Úcombine_permutations�  s    

ÿ

rÅ   c                 C   s’   |   ¡ \}}|d g}|dd… D ]/}|d }t|tƒr!t|tƒs'| |¡ q| ¡  | t|jd |jd ƒ¡ ||jd 9 }qt|g|¢R Ž S )zj
    Combine products of OneMatrix

    e.g. OneMatrix(2, 3) * OneMatrix(3, 4) -> 3 * OneMatrix(2, 4)
    r   r   NrJ   )r9   r^   r%   r¤   ÚpoprN   r±   )r   r>   r<   r¾   rÀ   r¿   r/   r/   r0   Úcombine_one_matrices—  s   

rÇ   c                    s‚   | j ‰ tˆ ƒdkr?ddlm} ˆ d jr'ˆ d jr'|‡ fdd„ˆ d j D ƒŽ S ˆ d jr?ˆ d jr?|‡ fdd„ˆ d j D ƒŽ S | S )zr
    Simplify MatMul expressions but distributing
    rational term to MatMul.

    e.g. 2*(A+B) -> 2*A + 2*B
    rÄ   r   )ÚMatAddr   c                    s   g | ]}t |ˆ d  ƒ ¡ ‘qS r“   ©r&   rj   ©rF   Úmatr°   r/   r0   rH   ¶  rŸ   z$distribute_monom.<locals>.<listcomp>c                    s   g | ]}t ˆ d  |ƒ ¡ ‘qS )r   rÉ   rÊ   r°   r/   r0   rH   ¸  rŸ   )r<   rb   ÚmataddrÈ   Ú	is_MatAddÚis_Rational)r   rÈ   r/   r°   r0   Údistribute_monom«  s   rÏ   c                 C   s   | dkS r»   r/   rž   r/   r/   r0   r1   ¼  s    r1   c                  G   sp   | d j | d jkrtdƒ‚g }d}t| ƒD ]\}}|j| | j kr5| t| ||d … Ž  ¡ ¡ |d }q|S )z'factor matrices only if they are squarer   rJ   z!Invalid matrices being multipliedr   )rK   rL   ÚRuntimeErrorrf   r¤   r&   rj   )r?   ÚoutÚstartr,   ÚMr/   r/   r0   r‡   Á  s   €r‡   c                 C   sÀ   g }g }| j D ]}|jr| |¡ q| |¡ q|d }|dd… D ]4}||jkr9tt |¡|ƒr9t|jd ƒ}q"|| 	¡ krOtt 
|¡|ƒrOt|jd ƒ}q"| |¡ |}q"| |¡ 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
    r   r   N)r<   rD   r¤   ÚTr   r   Ú
orthogonalr#   rN   Ú	conjugateÚunitaryr&   )rA   Úassumptionsr¶   Zexprargsr<   r·   rG   r/   r/   r0   Úrefine_MatMulÎ  s    


rÙ   N)AÚsympy.assumptions.askr   r   Úsympy.assumptions.refiner   Ú
sympy.corer   r   r   Zsympy.core.mulr   r	   Úsympy.core.numbersr
   r   Úsympy.core.symbolr   Úsympy.functionsr   Úsympy.strategiesr   r   r   r   r   r   r   Úsympy.matrices.exceptionsr   Úsympy.matrices.matrixbaser   Úsympy.utilities.exceptionsr   Z!sympy.matrices.expressions._shaper   r:   r‹   r   Úmatexprr   Úmatpowr   r    Úpermutationr!   Úspecialr"   r#   r$   r%   r&   Úregister_handlerclassr±   r´   r¸   rº   r¼   rÃ   rÅ   rÇ   rÏ   Úrulesr@   r‡   rÙ   r/   r/   r/   r0   Ú<module>   sJ    $ V*?þ"