
    Ed*-                       d dl mZ d dl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 d dlmZ d d	lmZmZmZ d d
lmZ erd dlmZ  G d de          Z G d dee          Z G d dee          Z  G d de          Z!dS )    )annotations)TYPE_CHECKING)simplifytrigsimp)call_highest_priority
_sympifyit)	StdFactKBdiffIntegral)factor)SAddMul)Expr)
BaseVectorc                     e Zd ZU dZded<    ed          d             Z ed          d             Z ed          d	             Z ed
          d             Z	 e
de           ed          d                         Z e
de           ed          d                         Zd Z e
de           ed          d                         Z ed          d             Zd'dZexj        ej        j        z  c_        eZd Zexj        ej        z  c_        d Zexj        ej        z  c_        d Zd Zd Zd  Zd! Zd" Zexj        ej        z  c_        d(d#Zd$ Z d% Z!e!xj        e"j        z  c_        d& Z#dS ))BasisDependentz
    Super class containing functionality common to vectors and
    dyadics.
    Named so because the representation of these quantities in
    sympy.vector is dependent on the basis they are expressed in.
    BasisDependentZerozero__radd__c                .    |                      | |          S N	_add_funcselfothers     ;lib/python3.11/site-packages/sympy/vector/basisdependent.py__add__zBasisDependent.__add__   s    ~~dE***    r!   c                .    |                      ||           S r   r   r   s     r    r   zBasisDependent.__radd__   s    ~~eT***r"   __rsub__c                0    |                      | |           S r   r   r   s     r    __sub__zBasisDependent.__sub__#   s    ~~dUF+++r"   r&   c                0    |                      ||            S r   r   r   s     r    r$   zBasisDependent.__rsub__'   s    ~~edU+++r"   r   __rmul__c                .    |                      | |          S r   	_mul_funcr   s     r    __mul__zBasisDependent.__mul__+   s     ~~dE***r"   r,   c                .    |                      ||           S r   r*   r   s     r    r(   zBasisDependent.__rmul__0   s     ~~eT***r"   c                B    |                      t          j        |           S r   )r+   r   NegativeOner   s    r    __neg__zBasisDependent.__neg__5   s    ~~amT222r"   __rtruediv__c                ,    |                      |          S r   )_div_helperr   s     r    __truediv__zBasisDependent.__truediv__8   s     &&&r"   r5   c                     t          d          S )NzInvalid divisor for division)	TypeErrorr   s     r    r2   zBasisDependent.__rtruediv__=   s    7888r"      Nd   Fc                    ||||||d}| j         }	| j                                        D ]\  }
}|	 |j        |fi ||
z  z  }	|	S )z
        Implements the SymPy evalf routine for this quantity.

        evalf's documentation
        =====================

        )subsmaxnchopstrictquadverbose)r   
componentsitemsevalf)r   nr;   r<   r=   r>   r?   r@   optionsveckvs               r    rC   zBasisDependent.evalfA   sp     tD6w0 0iO))++ 	- 	-DAq7171((((1,,CC
r"   c                b    fd| j                                         D             } | j        | S )z
        Implements the SymPy simplify routine for this quantity.

        simplify's documentation
        ========================

        c                6    g | ]\  }}t          |fi |z  S  )simp).0rG   rH   kwargss      r    
<listcomp>z+BasisDependent.simplify.<locals>.<listcomp>\   sB     < < <1a  ,,V,,q0 < < <r"   rA   rB   r   )r   rN   simp_componentss    ` r    r   zBasisDependent.simplifyT   H    < < < <#'?#8#8#:#:< < <t~//r"   c                b    fd| j                                         D             } | j        | S )z
        Implements the SymPy trigsimp routine, for this quantity.

        trigsimp's documentation
        ========================

        c                6    g | ]\  }}t          |fi |z  S rK   )tsimp)rM   rG   rH   optss      r    rO   z+BasisDependent.trigsimp.<locals>.<listcomp>j   sB     < < <1a !++d++a/ < < <r"   rP   )r   rV   trig_componentss    ` r    r   zBasisDependent.trigsimpb   rR   r"   c                     | j         di |S NrK   )r   )r   rN   s     r    _eval_simplifyzBasisDependent._eval_simplifyp   s    t}&&v&&&r"   c                     | j         di |S rY   )r   )r   rV   s     r    _eval_trigsimpzBasisDependent._eval_trigsimps   s    t}$$t$$$r"   c                ,    |                      |          S r   r
   )r   wrts     r    _eval_derivativezBasisDependent._eval_derivativev   s    yy~~r"   c                f    fd| j                                         D             } | j        | S )Nc                <    g | ]\  }}t          |gR i |z  S rK   r   )rM   rG   rH   assumptionssymbolss      r    rO   z1BasisDependent._eval_Integral.<locals>.<listcomp>z   sP     D D D#'1a  (CGCCC{CCaG D D Dr"   rP   )r   rc   rb   integral_componentss    `` r    _eval_IntegralzBasisDependent._eval_Integraly   sX    D D D D D+/?+@+@+B+BD D Dt~233r"   c                    | t           j        fS )z
        Returns the expression as a tuple wrt the following
        transformation -

        expression -> a/b -> a, b

        r   Oner0   s    r    as_numer_denomzBasisDependent.as_numer_denom~   s     QU{r"   c                f    fd| j                                         D             } | j        | S )z
        Implements the SymPy factor routine, on the scalar parts
        of a basis-dependent expression.

        factor's documentation
        ========================

        c                <    g | ]\  }}t          |gR i |z  S rK   )fctrrM   rG   rH   argsrN   s      r    rO   z)BasisDependent.factor.<locals>.<listcomp>   sJ     < < <1a  3D333F33a7 < < <r"   rP   )r   rn   rN   fctr_componentss    `` r    r   zBasisDependent.factor   sN    < < < < <#'?#8#8#:#:< < <t~//r"   c                    t           j        | fS )z2Efficiently extract the coefficient of a product. rg   )r   rationals     r    as_coeff_MulzBasisDependent.as_coeff_Mul   s    t}r"   c                L      fd j         D             }dt          |          fS )z4Efficiently extract the coefficient of a summation. c                0    g | ]}|j         |         z  S rK   )rA   )rM   xr   s     r    rO   z/BasisDependent.as_coeff_add.<locals>.<listcomp>   s%    ===Q##===r"   r   )rA   tuple)r   depsls   `  r    as_coeff_addzBasisDependent.as_coeff_add   s.    ====T_===%(({r"   c                    D ]&}t          |t                    rt          d          'fd| j                                        D             } | j        | S )z
        Implements the SymPy diff routine, for vectors.

        diff's documentation
        ========================

        zInvalid arg for differentiationc                <    g | ]\  }}t          |gR i |z  S rK   )dfrm   s      r    rO   z'BasisDependent.diff.<locals>.<listcomp>   sJ     < < <1a a1$111&11A5 < < <r"   )
isinstancer   r7   rA   rB   r   )r   rn   rN   ru   diff_componentss    ``  r    r   zBasisDependent.diff   s      	C 	CA!^,, C ABBBC< < < < <#'?#8#8#:#:< < <t~//r"   c                B      fd j         D             }  j        | S )z(Calls .doit() on each term in the Dyadicc                F    g | ]} j         |         j        d i |z  S )rK   )rA   doit)rM   ru   hintsr   s     r    rO   z'BasisDependent.doit.<locals>.<listcomp>   sH     5 5 5  34?1-2;;U;;a? 5 5 5r"   )rA   r   )r   r   doit_componentss   `` r    r   zBasisDependent.doit   sB    5 5 5 5 5$(O5 5 5t~//r"   )r8   Nr9   FFNF)F)$__name__
__module____qualname____doc____annotations__r   r!   r   r&   r$   r   NotImplementedr,   r(   r1   r5   r2   rC   r   rD   r   rL   r   rU   rZ   r\   r_   re   ri   r   rl   rr   ry   r   r|   r   rK   r"   r    r   r      s          :&&+ + '&+ 9%%+ + &%+ :&&, , '&, 9%%, , &%, Z((:&&+ + '& )(+ Z((9%%+ + &% )(+3 3 3 Z((>**' ' +* )(' =))9 9 *)9    
MMTZ''MMA
0 
0 
0 $
0 
0 
0 %' ' '% % %  4 4 4
  0 0 0 NNdl"NN     
0 0 0 	LLBJLL0 0 0 0 0r"   r   c                  "     e Zd ZdZ fdZ xZS )BasisDependentAddzt
    Denotes sum of basis dependent quantities such that they cannot
    be expressed as base or Mul instances.
    c                  
 i 
t          |          D ]\  }}t          || j                  sit          |t                    r | j        |j         }nDt          |t                    r | j        |j         }nt          t          |          dz             || j
        k    rt          |d          r1|j        D ])}
                    |d          |j        |         z   
|<   *t          
                                          }|D ]}
|         dk    r
|= t!          
          dk    r| j
        S 
fd
D             } t#                      j        | g|R i |}t          |t                    r | j        |j         S ddi}	t'          |	          |_        
|_        t          
                                          d         j        |_        |S )Nz  cannot be interpreted correctlyrA   r   c                &    g | ]}||         z  S rK   rK   )rM   ru   rA   s     r    rO   z-BasisDependentAdd.__new__.<locals>.<listcomp>   s"    9991z!}$999r"   commutativeT)	enumerater}   
_expr_typer   r+   rn   r   r   r7   strr   hasattrrA   getlistkeyslensuper__new__r	   _assumptions_components_sys)clsrn   rE   iargru   tempnewargsobjrb   rA   	__class__s             @r    r   zBasisDependentAdd.__new__   s   
  oo 	M 	MFAsc3>22 Hc3'' H'#-#(4CCS)) H'#-#(4CC#CHH$F%G H H H ch sL)) M M MA$.NN1a$8$83>!;L$LJqMMJOO%%&& 	" 	"A!}! "qM z??a 	8O :999j999eggoc7G777w77c3 	, 3=#(++$d+$[11$**++Q/4
r"   )r   r   r   r   r   __classcell__r   s   @r    r   r      sB         
( ( ( ( ( ( ( ( (r"   r   c                  (     e Zd ZdZ fdZd Z xZS )BasisDependentMulzJ
    Denotes product of base- basis dependent quantity with a scalar.
    c                    ddl m}m}m}m} d}t
          j        d}g }	|D ]}
t          |
 j                  r|dz  }d}|
t
          j	        k    rd}2t          |
 j
         j        f          r|dz  }|
j        }|
j        z  et          |
 j                  r|dz  }|
}t          |
||||f          r|	                    |
           |
z  |dk    rt!          d          |dk    rt#          |i |S |r j        S t          | j                  r fd|j        D             }  j        | S  t)                      j         |j        g|	R i |}t          |t,                    r  j        |j         S |j        |_        |_        ddi}t/          |          |_        |j        i|_        |j        j        |_        |S )	Nr   )CrossDotCurlGradientF   TzInvalid multiplicationc                <    g | ]}                     |          S rK   r*   )rM   ru   r   measure_numbers     r    rO   z-BasisDependentMul.__new__.<locals>.<listcomp>  s7     ' ' ' }}^Q77 ' ' 'r"   r   )sympy.vectorr   r   r   r   r   rh   r}   
_zero_funcZero
_base_funcr+   _base_instance_measure_numberr   append
ValueErrorr   r   rn   r   r   r   r	   r   r   r   )r   rn   rE   r   r   r   r   countzeroflag
extra_argsr   exprr   r   rb   r   r   s   `              @r    r   zBasisDependentMul.__new__   ss   ;;;;;;;;;;;;

  	& 	&C#s~.. &
 &C#.#-!@AA 
&
)#"55C// &
C%dH!=>> &!!#&&&&#%19 	)5666aZ 	)(((( 	8O dCM** 	+' ' ' ' ' I' ' 'G 3='**eggoc>"1))) ) ) !() ) c3 	, 3=#(++!0,$d+$[11.?&+
r"   c                    |                     | j                  }d|v sd|v sd|v rd|z   dz   }|dz   |                     | j                  z   S )N(-+)*)_printr   r   )r   printermeasure_strs      r    	_sympystrzBasisDependentMul._sympystr(  sj    nnT%9::; 	2#"4 	2{"	2+c1KS 7>>$2E#F#FFFr"   )r   r   r   r   r   r   r   r   s   @r    r   r      sY         8 8 8 8 8tG G G G G G Gr"   r   c                       e Zd ZU dZi Zded<   ded<    fdZd Z ed          d	             Z	e	Z
 ed
          d             Z ed          d             Z ed          d             Z ed          d             Zd Zd Zd Z xZS )r   z:
    Class to denote a zero basis dependent instance.
    zdict['BaseVector', Expr]rA   r   _latex_formc                    t                                          |           }t          t          j        | g                                          |_        |S r   )r   r   rv   r   r   __hash___hash)r   r   r   s     r    r   zBasisDependentZero.__new__7  s@    ggooc"" 163-((1133	
r"   c                    | j         S r   )r   r0   s    r    r   zBasisDependentZero.__hash__>  s
    zr"   __req__c                ,    t          || j                  S r   )r}   r   r   s     r    __eq__zBasisDependentZero.__eq__A  s    %111r"   r   c                N    t          || j                  r|S t          d          Nz#Invalid argument types for additionr}   r   r7   r   s     r    r!   zBasisDependentZero.__add__G  +    eT_-- 	CLABBBr"   r!   c                N    t          || j                  r|S t          d          r   r   r   s     r    r   zBasisDependentZero.__radd__N  r   r"   r$   c                P    t          || j                  r| S t          d          Nz&Invalid argument types for subtractionr   r   s     r    r&   zBasisDependentZero.__sub__U  s-    eT_-- 	F6MDEEEr"   r&   c                N    t          || j                  r|S t          d          r   r   r   s     r    r$   zBasisDependentZero.__rsub__\  s+    eT_-- 	FLDEEEr"   c                    | S r   rK   r0   s    r    r1   zBasisDependentZero.__neg__c  s    r"   c                    | S )z@
        Returns the normalized version of this vector.
        rK   r0   s    r    	normalizezBasisDependentZero.normalizef  s	     r"   c                    dS )N0rK   )r   r   s     r    r   zBasisDependentZero._sympystrl  s    sr"   )r   r   r   r   rA   r   r   r   r   r   r   r!   r   r&   r$   r1   r   r   r   r   s   @r    r   r   0  ss          ,.J----       9%%2 2 &%2 G:&&C C '&C 9%%C C &%C :&&F F '&F 9%%F F &%F          r"   r   N)"
__future__r   typingr   sympy.simplifyr   rL   r   rU   sympy.core.decoratorsr   r   sympy.core.assumptionsr	   sympy.core.functionr   r|   sympy.integrals.integralsr   sympy.polys.polytoolsr   rl   
sympy.corer   r   r   sympy.core.exprr   sympy.vector.vectorr   r   r   r   r   rK   r"   r    <module>r      s   " " " " " "             > > > > > > > > C C C C C C C C , , , , , , * * * * * * . . . . . . 0 0 0 0 0 0 " " " " " " " " " "             /......d0 d0 d0 d0 d0T d0 d0 d0N. . . . . . . .bDG DG DG DG DG DG DG DGN= = = = = = = = = =r"   