a
    RG5d>                     @   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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-m.Z.m/Z/ G dd de%eZ0e
1ee0fe0 dd Z2dd Z3dd Z4dd Z5dd Z6dd  Z7d!d" Z8d#d$ Z9d%d& Z:d'd( Z;e;e4e6e:e8eed)d* e5e7ee9fZ<eee0ee< iZ=d+d, Z>d-d. Z?e?ed< d/S )0    )askQ)handlers_dict)BasicsympifyS)mulMul)NumberIntegerDummyadjoint)rm_idunpacktypedflattenexhaustdo_onenew)
ShapeErrorNonInvertibleMatrixError)
MatrixBase)sympy_deprecation_warning   )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|}|r2ttt|}tj g|R  }| \}}|d urftdddd |dv rxt	|  ntdddd |s|S |r 
|S |S )	Nc                    s
    j | kS N)identity)icls ]/var/www/html/django/DPS/env/lib/python3.9/site-packages/sympy/matrices/expressions/matmul.py<lambda>/       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_target)TNzgPassing check=False to MatMul is deprecated and the check argument will be removed in a future version.)r+   listfiltermapr   r   __new__as_coeff_matricesr   validate	_evaluate)r.   r'   r(   r)   argsobjfactormatricesr/   r-   r0   r8   )   s2    

zMatMul.__new__c                 C   s   t |S r*   )canonicalize)r.   exprr/   r/   r0   r;   N   s    zMatMul._evaluatec                 C   s$   dd | j D }|d j|d jfS )Nc                 S   s   g | ]}|j r|qS r/   	is_Matrix.0argr/   r/   r0   
<listcomp>T   r2   z MatMul.shape.<locals>.<listcomp>r   )r<   rowscols)selfr?   r/   r/   r0   shapeR   s    zMatMul.shapec                    sp  ddl m} ddlm  |  \}}t|dkrD||d ||f  S d gt|d  d gt|d  }|d< |d< dd }	|d|	 tdt|D ]}t|< qt	|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}|rl| S |S )Nr   )SumImmutableMatrixr   rH   c                  s   s    d} t d|  V  | d7 } qd S )Nr   zi_%ir   )counterr/   r/   r0   ff   s    zMatMul._entry.<locals>.fdummy_generatorc                    s,   g | ]$\}}|j | |d    dqS )r   )rR   )_entryrE   r,   rF   )rR   indicesr/   r0   rG   s   r2   z!MatMul._entry.<locals>.<listcomp>c                 3   s   | ]}|  V  qd S r*   hasrE   vrN   r/   r0   	<genexpr>u   r2   z MatMul._entry.<locals>.<genexpr>Tc                 s   s   | ]}t |ttfV  qd S r*   )
isinstancer   intrX   r/   r/   r0   rZ   }   r2   F)sympy.concrete.summationsrM   sympy.matrices.immutablerO   r9   lengetrangenext	enumeraterL   r	   fromiteranyzipdoit)rK   r,   jexpandkwargsrM   coeffr?   Z
ind_rangesrQ   rF   Zexpr_in_sumresultr/   )rO   rR   rU   r0   rS   W   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   s   g | ]}|j s|qS r/   rB   rE   xr/   r/   r0   rG      r2   z,MatMul.as_coeff_matrices.<locals>.<listcomp>c                 S   s   g | ]}|j r|qS r/   rB   rm   r/   r/   r0   rG      r2   Fz3noncommutative scalars in MatMul are not supported.)r<   r	   is_commutativeNotImplementedError)rK   scalarsr?   rk   r/   r/   r0   r9      s    
zMatMul.as_coeff_matricesc                 C   s   |   \}}|t| fS r*   )r9   r&   rK   rk   r?   r/   r/   r0   as_coeff_mmul   s    zMatMul.as_coeff_mmulc                    s    t t| jf i |}| |S r*   )superr&   ri   r;   )rK   rj   expanded	__class__r/   r0   ri      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   s   g | ]}t |qS r/   r   rD   r/   r/   r0   rG      r2   z*MatMul._eval_transpose.<locals>.<listcomp>NrH   )r9   r&   rg   rr   r/   r/   r0   _eval_transpose   s    zMatMul._eval_transposec                 C   s"   t dd | jd d d D   S )Nc                 S   s   g | ]}t |qS r/   r   rD   r/   r/   r0   rG      r2   z(MatMul._eval_adjoint.<locals>.<listcomp>rH   )r&   r<   rg   rK   r/   r/   r0   _eval_adjoint   s    zMatMul._eval_adjointc                 C   s<   |   \}}|dkr0ddlm} |||  S tdd S )Nr   )tracezCan't simplify any further)rs   r{   rg   rp   )rK   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_squaresrI   r	   r5   r7   )rK   r~   r>   r?   Zsquare_matricesr/   r/   r0   _eval_determinant   s    zMatMul._eval_determinantc                 C   sD   z$t dd | jd d d D   W S  ty>   t|  Y S 0 d S )Nc                 S   s&   g | ]}t |tr| n|d  qS )rH   )r[   r   inverserD   r/   r/   r0   rG      s   z(MatMul._eval_inverse.<locals>.<listcomp>rH   )r&   r<   rg   r   r   ry   r/   r/   r0   _eval_inverse   s    zMatMul._eval_inversec                    s<     dd}|r& fdd| jD }n| j}tt| }|S )NdeepTc                    s   g | ]}|j f i  qS r/   )rg   rD   hintsr/   r0   rG      r2   zMatMul.doit.<locals>.<listcomp>)r`   r<   r@   r&   )rK   r   r   r<   rA   r/   r   r0   rg      s    zMatMul.doitc                    sj   dd  j D }dd  j D }|rbt|}t|}|rb|rbt||krbtd fdd|D  ||gS )Nc                 S   s   g | ]}|j r|qS r/   ro   rm   r/   r/   r0   rG      r2   z#MatMul.args_cnc.<locals>.<listcomp>c                 S   s   g | ]}|j s|qS r/   r   rm   r/   r/   r0   rG      r2   z"repeated commutative arguments: %sc                    s$   g | ]}t  j|d kr|qS r   )r5   r<   count)rE   ciry   r/   r0   rG      r2   )r<   r_   set
ValueError)rK   csetwarnrj   Zcoeff_cZcoeff_ncclenr/   ry   r0   args_cnc   s    zMatMul.args_cncc                    s   ddl m  fddt| jD }g }|D ]}| jd | }| j|d d  }|r`t|}nt| jd }|rt fddt|D }nt| jd }| j| 	}	|	D ]"}
|

| |
| ||
 qq,|S )Nr   	Transposec                    s   g | ]\}}|  r|qS r/   rV   rT   rn   r/   r0   rG      r2   z8MatMul._eval_derivative_matrix_lines.<locals>.<listcomp>c                    s"   g | ]}|j r | n|qS r/   )rC   rg   )rE   r,   r   r/   r0   rG      r2   r   )r    r   rc   r<   r&   rd   r#   rL   reversed_eval_derivative_matrix_linesappend_firstappend_secondappend)rK   rn   Z
with_x_indlinesindZ	left_argsZ
right_argsZ	right_matZleft_revdr,   r/   )r   rn   r0   r      s$    

z$MatMul._eval_derivative_matrix_lines)T)FT)__name__
__module____qualname____doc__	is_MatMulr$   r+   r8   classmethodr;   propertyrL   rS   r9   rs   ri   rx   rz   r}   r   r   rg   r   r   __classcell__r/   r/   rv   r0   r&      s(   %


*	
r&   c                  G   sJ   t t| d D ]4}| ||d  \}}|j|jkrtd||f qdS )z, Checks for valid shapes for args of MatMul r      z"Matrices %s and %s are not alignedN)ra   r_   rJ   rI   r   )r?   r,   ABr/   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_zerorC   is_ZeroMatrixrD   r/   r/   r0   rZ     s   zany_zeros.<locals>.<genexpr>c                 S   s   g | ]}|j r|qS r/   rB   rD   r/   r/   r0   rG     r2   zany_zeros.<locals>.<listcomp>r   rH   )re   r<   r"   rI   rJ   )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 ]8}t|ttfr^t|ttfr^|| }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]
    c                 s   s   | ]}t |tV  qd S r*   )r[   r   rD   r/   r/   r0   rZ   &  r2   z!merge_explicit.<locals>.<genexpr>r   r   N)re   r<   r[   r   r
   r   r&   )matmulnewargslastrF   r/   r/   r0   merge_explicit
  s    



r   c                 C   s>   |   \}}tdd |}||kr6t|g|jR  S | S dS )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
    c                 S   s
   | j du S )NT)is_Identityr   r/   r/   r0   r1   C  r2   zremove_ids.<locals>.<lambda>N)rs   r   r   r<   )r   r>   r|   rl   r/   r/   r0   
remove_ids4  s
    r   c                 C   s(   |   \}}|dkr$t|g|R  S | S Nr   )r9   r   )r   r>   r?   r/   r/   r0   factor_in_frontI  s    r   c              	   C   s(  |   \}}|d g}tdt|D ]}|d }|| }t|trt|jtr|jj}t|}t||| d kr|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 ]}|
||< qq$|jdks&|jdkr2|| q$t|trJ|j\}}n|tj }}t|trn|j\}}n|tj }}||kr|| }t||jdd|d< q$nft|tsz| }W n ty   d}Y n0 |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   rH   NF)r   )r9   ra   r_   r[   r   rF   r&   r<   r5   r#   rL   	is_squarer   r   r   Onerg   r   r   r   r   )r   r>   r<   new_argsr,   r   r   ZBargslZAargsr+   rh   ZA_baseZA_expZB_baseZB_expnew_expZ
B_base_invr/   r/   r0   combine_powersO  sX    




r   c           	      C   s   | j }t|}|dk r| S |d g}td|D ]X}|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   r   rH   )r<   r_   ra   r[   r!   r   r&   )	r   r<   r   rl   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rBt|tsN|| 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   NrH   )r9   r[   r%   r   poprL   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rN d jrN| 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&   rg   rE   matr   r/   r0   rG     r2   z$distribute_monom.<locals>.<listcomp>c                    s   g | ]}t  d  | qS )r   r   r   r   r/   r0   rG     r2   )r<   r_   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     r2   r1   c                  G   sp   | d j | d jkrtdg }d}t| D ]>\}}|j| | j kr,|t| ||d     |d }q,|S )z'factor matrices only if they are squarer   rH   z!Invalid matrices being multipliedr   )rI   rJ   RuntimeErrorrc   r   r&   rg   )r?   outstartr,   Mr/   r/   r0   r     s    
r   c                 C   s   g }g }| j D ] }|jr$|| q|| q|d }|dd D ]h}||jkrrtt||rrt|jd }qD||	 krtt
||rt|jd }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
    r   r   N)r<   rC   r   Tr   r   
orthogonalr#   rL   	conjugateunitaryr&   )rA   assumptionsr   Zexprargsr<   r   rF   r/   r/   r0   refine_MatMul  s     


r   N)@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.commonr   r   sympy.matrices.matricesr   sympy.utilities.exceptionsr   r   r   matexprr   matpowr   r    permutationr!   specialr"   r#   r$   r%   r&   register_handlerclassr:   r   r   r   r   r   r   r   r   r   rulesr@   r   r   r/   r/   r/   r0   <module>   sH   $ \
*?"