o
    §ƒðjbO  ã                   @  sž  d dl mZ d dlmZ d dlmZmZ d dl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mZmZmZ d dlmZ d dl m!Z!m"Z"m#Z# d dl$m%Z% G dd„ deƒZ&dd„ Z'de'eƒgiej(e&< G dd„ de&e
ƒZ)G dd„ dee&ƒZ*G dd„ dee&ƒZ+G dd„ dee&ƒZ,G dd„ de&ƒZ-G dd „ d eƒZ.d!d"„ Z/d#d$„ Z0e&e&_1e+e&_2e*e&_3e,e&_4e)e&_5e,ƒ e&_6d%S )&é    )Úannotations)Úproduct)ÚAddÚBasic)Ú	StdFactKB)Ú
AtomicExprÚExpr)ÚPow)ÚS)Údefault_sort_key)Úsympify©Úsqrt)ÚImmutableDenseMatrix)ÚBasisDependentZeroÚBasisDependentÚBasisDependentMulÚBasisDependentAdd)Ú
CoordSys3D)ÚDyadicÚ
BaseDyadicÚ	DyadicAdd)Ú
VectorKindc                   @  sö   e Zd ZU dZdZdZdZded< ded< ded< ded	< ded
< ded< eƒ Z	ded< e
dd„ ƒZdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zeje_dd„ Zdd„ Zeje_dd „ Zd.d!d"„Ze
d#d$„ ƒZd%d&„ Zeje_d'd(„ Zd)d*„ Zd+d,„ Zd-S )/ÚVectorz�
    Super class for all Vector classes.
    Ideally, neither this class nor any of its subclasses should be
    instantiated by the user.
    FTg      (@ztype[Vector]Ú
_expr_typeÚ	_mul_funcÚ	_add_funcÚ
_zero_funcÚ
_base_funcÚ
VectorZeroÚzeror   Úkindc                 C  ó   | j S )a‚  
        Returns the components of this vector in the form of a
        Python dictionary mapping BaseVector instances to the
        corresponding measure numbers.

        Examples
        ========

        >>> from sympy.vector import CoordSys3D
        >>> C = CoordSys3D('C')
        >>> v = 3*C.i + 4*C.j + 5*C.k
        >>> v.components
        {C.i: 3, C.j: 4, C.k: 5}

        )Ú_components©Úself© r&   ú•/tmp/claude-1000/-var-www-html-academy/3f42efd1-c2b7-4d08-9b05-30d86bb35479/scratchpad/piper/venv/lib/python3.10/site-packages/sympy/vector/vector.pyÚ
components(   s   zVector.componentsc                 C  s   t | | @ ƒS )z7
        Returns the magnitude of this vector.
        r   r$   r&   r&   r'   Ú	magnitude=   ó   zVector.magnitudec                 C  s   | |   ¡  S )z@
        Returns the normalized version of this vector.
        )r)   r$   r&   r&   r'   Ú	normalizeC   r*   zVector.normalizec                 C  s   | | }|  |¡}| d¡S )aM  
        Check if ``self`` and ``other`` are identically equal vectors.

        Explanation
        ===========

        Checks if two vector expressions are equal for all possible values of
        the symbols present in the expressions.

        Examples
        ========

        >>> from sympy.vector import CoordSys3D
        >>> from sympy.abc import x, y
        >>> from sympy import pi
        >>> C = CoordSys3D('C')

        Compare vectors that are equal or not:

        >>> C.i.equals(C.j)
        False
        >>> C.i.equals(C.i)
        True

        These two vectors are equal if `x = y` but are not identically equal
        as expressions since for some values of `x` and `y` they are unequal:

        >>> v1 = x*C.i + C.j
        >>> v2 = y*C.i + C.j
        >>> v1.equals(v1)
        True
        >>> v1.equals(v2)
        False

        Vectors from different coordinate systems can be compared:

        >>> D = C.orient_new_axis('D', pi/2, C.i)
        >>> D.j.equals(C.j)
        False
        >>> D.j.equals(C.k)
        True

        Parameters
        ==========

        other: Vector
            The other vector expression to compare with.

        Returns
        =======

        ``True``, ``False`` or ``None``. A return value of ``True`` indicates
        that the two vectors are identically equal. A return value of ``False``
        indicates that they are not. In some cases it is not possible to
        determine if the two vectors are identically equal and ``None`` is
        returned.

        See Also
        ========

        sympy.core.expr.Expr.equals
        r   )ÚdotÚequals)r%   ÚotherÚdiffÚ	diff_mag2r&   r&   r'   r-   I   s   ?

zVector.equalsc                   s°   t |tƒr/t ˆ tƒrtjS tj}|j ¡ D ]\}}|jd  ˆ ¡}||| |jd  7 }q|S ddl	m
} t ||tfƒsFtt|ƒd d ƒ‚t ||ƒrS‡ fdd„}|S tˆ |ƒS )aN  
        Returns the dot product of this Vector, either with another
        Vector, or a Dyadic, or a Del operator.
        If 'other' is a Vector, returns the dot product scalar (SymPy
        expression).
        If 'other' is a Dyadic, the dot product is returned as a Vector.
        If 'other' is an instance of Del, returns the directional
        derivative operator as a Python function. If this function is
        applied to a scalar expression, it returns the directional
        derivative of the scalar field wrt this Vector.

        Parameters
        ==========

        other: Vector/Dyadic/Del
            The Vector or Dyadic we are dotting with, or a Del operator .

        Examples
        ========

        >>> from sympy.vector import CoordSys3D, Del
        >>> C = CoordSys3D('C')
        >>> delop = Del()
        >>> C.i.dot(C.j)
        0
        >>> C.i & C.i
        1
        >>> v = 3*C.i + 4*C.j + 5*C.k
        >>> v.dot(C.k)
        5
        >>> (C.i & delop)(C.x*C.y*C.z)
        C.y*C.z
        >>> d = C.i.outer(C.i)
        >>> C.i.dot(d)
        C.i

        r   é   )ÚDelz is not a vector, dyadic or zdel operatorc                   s   ddl m} || ˆ ƒS )Nr   )Údirectional_derivative)Úsympy.vector.functionsr3   )Úfieldr3   r$   r&   r'   r3   Ã   s   
z*Vector.dot.<locals>.directional_derivative)Ú
isinstancer   r   r   r    r(   ÚitemsÚargsr,   Úsympy.vector.deloperatorr2   Ú	TypeErrorÚstr)r%   r.   ÚoutvecÚkÚvÚvect_dotr2   r3   r&   r$   r'   r,   Œ   s"   
(
ÿ

z
Vector.dotc                 C  ó
   |   |¡S ©N©r,   ©r%   r.   r&   r&   r'   Ú__and__Ê   ó   
zVector.__and__c                 C  sn   t |tƒr2t | tƒrtjS tj}|j ¡ D ]\}}|  |jd ¡}| |jd ¡}||| 7 }q|S t| |ƒS )aÃ  
        Returns the cross product of this Vector with another Vector or
        Dyadic instance.
        The cross product is a Vector, if 'other' is a Vector. If 'other'
        is a Dyadic, this returns a Dyadic instance.

        Parameters
        ==========

        other: Vector/Dyadic
            The Vector or Dyadic we are crossing with.

        Examples
        ========

        >>> from sympy.vector import CoordSys3D
        >>> C = CoordSys3D('C')
        >>> C.i.cross(C.j)
        C.k
        >>> C.i ^ C.i
        0
        >>> v = 3*C.i + 4*C.j + 5*C.k
        >>> v ^ C.i
        5*C.j + (-4)*C.k
        >>> d = C.i.outer(C.i)
        >>> C.j.cross(d)
        (-1)*(C.k|C.i)

        r   r1   )	r6   r   r   r    r(   r7   Úcrossr8   Úouter)r%   r.   Úoutdyadr=   r>   Úcross_productrG   r&   r&   r'   rF   Ï   s   
 

zVector.crossc                 C  r@   rA   ©rF   rC   r&   r&   r'   Ú__xor__û   rE   zVector.__xor__c                 C  sT   t |tƒs	tdƒ‚t | tƒst |tƒrtjS dd„ t| j ¡ |j ¡ ƒD ƒ}t	|Ž S )a±  
        Returns the outer product of this vector with another, in the
        form of a Dyadic instance.

        Parameters
        ==========

        other : Vector
            The Vector with respect to which the outer product is to
            be computed.

        Examples
        ========

        >>> from sympy.vector import CoordSys3D
        >>> N = CoordSys3D('N')
        >>> N.i.outer(N.j)
        (N.i|N.j)

        z!Invalid operand for outer productc                 S  s*   g | ]\\}}\}}|| t ||ƒ ‘qS r&   )r   )Ú.0Úk1Úv1Úk2Úv2r&   r&   r'   Ú
<listcomp>  s   * z Vector.outer.<locals>.<listcomp>)
r6   r   r:   r   r   r    r   r(   r7   r   )r%   r.   r8   r&   r&   r'   rG      s   

ÿÿzVector.outerc                 C  sL   |   tj¡r|rtjS tjS |r|  |¡|  | ¡ S |  |¡|  | ¡ |  S )a«  
        Returns the vector or scalar projection of the 'other' on 'self'.

        Examples
        ========

        >>> from sympy.vector.coordsysrect import CoordSys3D
        >>> C = CoordSys3D('C')
        >>> i, j, k = C.base_vectors()
        >>> v1 = i + j + k
        >>> v2 = 3*i + 4*j
        >>> v1.projection(v2)
        7/3*C.i + 7/3*C.j + 7/3*C.k
        >>> v1.projection(v2, scalar=True)
        7/3

        )r-   r   r    r
   ÚZeror,   )r%   r.   Úscalarr&   r&   r'   Ú
projection$  s
   zVector.projectionc                   sP   ddl m} tˆ tƒrtjtjtjfS tt|ˆ ƒƒƒ ¡ }t	‡ fdd„|D ƒƒS )aé  
        Returns the components of this vector but the output includes
        also zero values components.

        Examples
        ========

        >>> from sympy.vector import CoordSys3D, Vector
        >>> C = CoordSys3D('C')
        >>> v1 = 3*C.i + 4*C.j + 5*C.k
        >>> v1._projections
        (3, 4, 5)
        >>> v2 = C.x*C.y*C.z*C.i
        >>> v2._projections
        (C.x*C.y*C.z, 0, 0)
        >>> v3 = Vector.zero
        >>> v3._projections
        (0, 0, 0)
        r   )Ú_get_coord_systemsc                   ó   g | ]}ˆ   |¡‘qS r&   rB   ©rL   Úir$   r&   r'   rQ   X  ó    z'Vector._projections.<locals>.<listcomp>)
Úsympy.vector.operatorsrU   r6   r   r
   rR   ÚnextÚiterÚbase_vectorsÚtuple)r%   rU   Úbase_vecr&   r$   r'   Ú_projections>  s
   
zVector._projectionsc                 C  r@   rA   )rG   rC   r&   r&   r'   Ú__or__Z  rE   zVector.__or__c                   s   t ‡ fdd„| ¡ D ƒƒS )a  
        Returns the matrix form of this vector with respect to the
        specified coordinate system.

        Parameters
        ==========

        system : CoordSys3D
            The system wrt which the matrix form is to be computed

        Examples
        ========

        >>> from sympy.vector import CoordSys3D
        >>> C = CoordSys3D('C')
        >>> from sympy.abc import a, b, c
        >>> v = a*C.i + b*C.j + c*C.k
        >>> v.to_matrix(C)
        Matrix([
        [a],
        [b],
        [c]])

        c                   rV   r&   rB   )rL   Úunit_vecr$   r&   r'   rQ   y  rY   z$Vector.to_matrix.<locals>.<listcomp>)ÚMatrixr]   )r%   Úsystemr&   r$   r'   Ú	to_matrix_  s   ÿzVector.to_matrixc                 C  s:   i }| j  ¡ D ]\}}| |jtj¡||  ||j< q|S )aÅ  
        The constituents of this vector in different coordinate systems,
        as per its definition.

        Returns a dict mapping each CoordSys3D to the corresponding
        constituent Vector.

        Examples
        ========

        >>> from sympy.vector import CoordSys3D
        >>> R1 = CoordSys3D('R1')
        >>> R2 = CoordSys3D('R2')
        >>> v = R1.i + R2.i
        >>> v.separate() == {R1: R1.i, R2: R2.i}
        True

        )r(   r7   Úgetrd   r   r    )r%   ÚpartsÚvectÚmeasurer&   r&   r'   Úseparate|  s   ÿzVector.separatec                 C  sR   t | tƒrt |tƒrtdƒ‚t | tƒr%|tjkrtdƒ‚t| t|tjƒƒS tdƒ‚)z( Helper for division involving vectors. zCannot divide two vectorszCannot divide a vector by zeroz#Invalid division involving a vector)	r6   r   r:   r
   rR   Ú
ValueErrorÚ	VectorMulr	   ÚNegativeOne)Úoner.   r&   r&   r'   Ú_div_helper–  s   

zVector._div_helperN)F)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú	is_scalarÚ	is_VectorÚ_op_priorityÚ__annotations__r   r!   Úpropertyr(   r)   r+   r-   r,   rD   rF   rK   rG   rT   r`   ra   re   rj   ro   r&   r&   r&   r'   r      s@   
 
C>,
$
r   c                   s   ‡ fdd„}|S )Nc                   sN   t tiˆ  }g }| jD ]}t|jtƒr| |¡ q|tkr%t|Ž jdd�S d S )NF)Údeep)r   Ú	VectorAddr8   r6   r!   r   ÚappendÚdoit)ÚexprÚ	vec_classÚvectorsÚterm©Úclsr&   r'   Ú_postprocessor¤  s   

€ÿz)get_postprocessor.<locals>._postprocessorr&   )r‚   rƒ   r&   r�   r'   Úget_postprocessor£  s   	r„   r   c                      sR   e Zd ZdZd‡ fdd„	Zedd„ ƒZdd„ Zd	d
„ Zedd„ ƒZ	dd„ Z
‡  ZS )Ú
BaseVectorz)
    Class to denote a base vector.

    Nc                   sà   |d u r	d  |¡}|d u rd  |¡}t|ƒ}t|ƒ}|tddƒvr%tdƒ‚t|tƒs.tdƒ‚|j| }tƒ  	| t
|ƒ|¡}||_|t
ji|_t
j|_|jd | |_d| |_||_||_||f|_d	d
i}t|ƒ|_||_|S )Nzx{}zx_{}r   é   zindex must be 0, 1 or 2zsystem should be a CoordSys3DÚ.Ú ÚcommutativeT)Úformatr;   Úrangerk   r6   r   r:   Ú_vector_namesÚsuperÚ__new__r
   Ú_base_instanceÚOner#   Ú_measure_numberÚ_nameÚ_pretty_formÚ_latex_formÚ_systemÚ_idr   Ú_assumptionsÚ_sys)r‚   Úindexrd   Ú
pretty_strÚ	latex_strÚnameÚobjÚassumptions©Ú	__class__r&   r'   rŽ   º  s0   






zBaseVector.__new__c                 C  r"   rA   )r•   r$   r&   r&   r'   rd   Ý  ó   zBaseVector.systemc                 C  r"   rA   )r’   )r%   Úprinterr&   r&   r'   Ú	_sympystrá  s   zBaseVector._sympystrc                 C  s"   | j \}}| |¡d |j|  S )Nr‡   )r–   Ú_printrŒ   )r%   r¢   r™   rd   r&   r&   r'   Ú
_sympyreprä  s   
zBaseVector._sympyreprc                 C  s   | hS rA   r&   r$   r&   r&   r'   Úfree_symbolsè  r¡   zBaseVector.free_symbolsc                 C  s   | S rA   r&   r$   r&   r&   r'   Ú_eval_conjugateì  s   zBaseVector._eval_conjugate)NN)rp   rq   rr   rs   rŽ   rx   rd   r£   r¥   r¦   r§   Ú__classcell__r&   r&   rŸ   r'   r…   ´  s    #

r…   c                   @  ó    e Zd ZdZdd„ Zdd„ ZdS )rz   z2
    Class to denote sum of Vector instances.
    c                 O  ó   t j| g|¢R i |¤Ž}|S rA   )r   rŽ   ©r‚   r8   Úoptionsr�   r&   r&   r'   rŽ   õ  ó   zVectorAdd.__new__c           	      C  sz   d}t |  ¡  ¡ ƒ}|jdd„ d� |D ]"\}}| ¡ }|D ]}||jv r5| j| | }|| |¡d 7 }qq|d d… S )Nrˆ   c                 S  s   | d   ¡ S )Nr   )Ú__str__)Úxr&   r&   r'   Ú<lambda>ü  s    z%VectorAdd._sympystr.<locals>.<lambda>©Úkeyz + éýÿÿÿ)Úlistrj   r7   Úsortr]   r(   r¤   )	r%   r¢   Úret_strr7   rd   rh   Ú
base_vectsr¯   Ú	temp_vectr&   r&   r'   r£   ù  s   
€ýzVectorAdd._sympystrN)rp   rq   rr   rs   rŽ   r£   r&   r&   r&   r'   rz   ð  s    rz   c                   @  s0   e Zd ZdZdd„ Zedd„ ƒZedd„ ƒZdS )	rl   z>
    Class to denote products of scalars and BaseVectors.
    c                 O  rª   rA   )r   rŽ   r«   r&   r&   r'   rŽ     r­   zVectorMul.__new__c                 C  r"   )z) The BaseVector involved in the product. )r�   r$   r&   r&   r'   Úbase_vector  s   zVectorMul.base_vectorc                 C  r"   )zU The scalar expression involved in the definition of
        this VectorMul.
        )r‘   r$   r&   r&   r'   Úmeasure_number  s   zVectorMul.measure_numberN)rp   rq   rr   rs   rŽ   rx   r¹   rº   r&   r&   r&   r'   rl     s    
rl   c                   @  s$   e Zd ZdZdZdZdZdd„ ZdS )r   z'
    Class to denote a zero vector
    g333333(@Ú0z\mathbf{\hat{0}}c                 C  s   t  | ¡}|S rA   )r   rŽ   )r‚   r�   r&   r&   r'   rŽ   %  s   
zVectorZero.__new__N)rp   rq   rr   rs   rv   r“   r”   rŽ   r&   r&   r&   r'   r     s    r   c                   @  r©   )ÚCrossaŒ  
    Represents unevaluated Cross product.

    Examples
    ========

    >>> from sympy.vector import CoordSys3D, Cross
    >>> R = CoordSys3D('R')
    >>> v1 = R.i + R.j + R.k
    >>> v2 = R.x * R.i + R.y * R.j + R.z * R.k
    >>> Cross(v1, v2)
    Cross(R.i + R.j + R.k, R.x*R.i + R.y*R.j + R.z*R.k)
    >>> Cross(v1, v2).doit()
    (-R.y + R.z)*R.i + (R.x - R.z)*R.j + (-R.x + R.y)*R.k

    c                 C  sJ   t |ƒ}t |ƒ}t|ƒt|ƒkrt||ƒ S t | ||¡}||_||_|S rA   )r   r   r¼   r   rŽ   Ú_expr1Ú_expr2©r‚   Úexpr1Úexpr2r�   r&   r&   r'   rŽ   <  s   zCross.__new__c                 K  ó   t | j| jƒS rA   )rF   r½   r¾   ©r%   Úhintsr&   r&   r'   r|   F  ó   z
Cross.doitN©rp   rq   rr   rs   rŽ   r|   r&   r&   r&   r'   r¼   *  s    
r¼   c                   @  r©   )ÚDota�  
    Represents unevaluated Dot product.

    Examples
    ========

    >>> from sympy.vector import CoordSys3D, Dot
    >>> from sympy import symbols
    >>> R = CoordSys3D('R')
    >>> a, b, c = symbols('a b c')
    >>> v1 = R.i + R.j + R.k
    >>> v2 = a * R.i + b * R.j + c * R.k
    >>> Dot(v1, v2)
    Dot(R.i + R.j + R.k, a*R.i + b*R.j + c*R.k)
    >>> Dot(v1, v2).doit()
    a + b + c

    c                 C  sB   t |ƒ}t |ƒ}t||gtd�\}}t | ||¡}||_||_|S )Nr±   )r   Úsortedr   r   rŽ   r½   r¾   r¿   r&   r&   r'   rŽ   ^  s   zDot.__new__c                 K  rÂ   rA   )r,   r½   r¾   rÃ   r&   r&   r'   r|   g  rÅ   zDot.doitNrÆ   r&   r&   r&   r'   rÇ   J  s    	rÇ   c                   sŽ  t ˆ tƒrt ‡fdd„ˆ jD ƒ¡S t ˆtƒr$t ‡ fdd„ˆjD ƒ¡S t ˆ tƒr‡t ˆtƒr‡ˆ jˆjkreˆ jd }ˆjd }||krEtjS h d£ 	||h¡ 
¡ }|d d |krZdnd}|ˆ j ¡ |  S dd	lm} z|ˆ ˆjƒ}W n ty�   tˆ ˆƒ Y S w t|ˆƒS t ˆ tƒs‘t ˆtƒr”tjS t ˆ tƒr«ttˆ j ¡ ƒƒ\}}	|	t|ˆƒ S t ˆtƒrÂttˆj ¡ ƒƒ\}
}|tˆ |
ƒ S tˆ ˆƒS )
a^  
    Returns cross product of two vectors.

    Examples
    ========

    >>> from sympy.vector import CoordSys3D
    >>> from sympy.vector.vector import cross
    >>> R = CoordSys3D('R')
    >>> v1 = R.i + R.j + R.k
    >>> v2 = R.x * R.i + R.y * R.j + R.z * R.k
    >>> cross(v1, v2)
    (-R.y + R.z)*R.i + (R.x - R.z)*R.j + (-R.x + R.y)*R.k

    c                 3  ó   � | ]}t |ˆ ƒV  qd S rA   rJ   rW   ©Úvect2r&   r'   Ú	<genexpr>|  ó   € zcross.<locals>.<genexpr>c                 3  ó   � | ]}t ˆ |ƒV  qd S rA   rJ   rW   ©Úvect1r&   r'   rÌ   ~  rÍ   r   >   r   r1   é   r1   r†   éÿÿÿÿ©Úexpress)r6   r   rz   Úfromiterr8   r…   r˜   r   r    Ú
differenceÚpopr]   Ú	functionsrÔ   rk   r¼   rF   r   rl   r[   r\   r(   r7   )rÐ   rË   Ún1Ún2Ún3ÚsignrÔ   r>   rN   Úm1rP   Úm2r&   ©rÐ   rË   r'   rF   k  s:   



ÿ



rF   c                   s@  t ˆ tƒrt ‡fdd„ˆ jD ƒ¡S t ˆtƒr$t ‡ fdd„ˆjD ƒ¡S t ˆ tƒr`t ˆtƒr`ˆ jˆjkr>ˆ ˆkr;tjS tjS ddl	m
} z|ˆˆ jƒ}W n tyZ   tˆ ˆƒ Y S w tˆ |ƒS t ˆ tƒsjt ˆtƒrmtjS t ˆ tƒr„ttˆ j ¡ ƒƒ\}}|t|ˆƒ S t ˆtƒr›ttˆj ¡ ƒƒ\}}|tˆ |ƒ S tˆ ˆƒS )a2  
    Returns dot product of two vectors.

    Examples
    ========

    >>> from sympy.vector import CoordSys3D
    >>> from sympy.vector.vector import dot
    >>> R = CoordSys3D('R')
    >>> v1 = R.i + R.j + R.k
    >>> v2 = R.x * R.i + R.y * R.j + R.z * R.k
    >>> dot(v1, v2)
    R.x + R.y + R.z

    c                 3  rÉ   rA   rB   rW   rÊ   r&   r'   rÌ   ¬  rÍ   zdot.<locals>.<genexpr>c                 3  rÎ   rA   rB   rW   rÏ   r&   r'   rÌ   ®  rÍ   r1   rÓ   )r6   r   rÕ   r8   r…   r˜   r
   r�   rR   rØ   rÔ   rk   rÇ   r,   r   rl   r[   r\   r(   r7   )rÐ   rË   rÔ   r>   rN   rÝ   rP   rÞ   r&   rß   r'   r,   ›  s.   

ÿ



r,   N)7Ú
__future__r   Ú	itertoolsr   Ú
sympy.corer   r   Úsympy.core.assumptionsr   Úsympy.core.exprr   r   Úsympy.core.powerr	   Úsympy.core.singletonr
   Úsympy.core.sortingr   Úsympy.core.sympifyr   Ú(sympy.functions.elementary.miscellaneousr   Úsympy.matrices.immutabler   rc   Úsympy.vector.basisdependentr   r   r   r   Úsympy.vector.coordsysrectr   Úsympy.vector.dyadicr   r   r   Úsympy.vector.kindr   r   r„   Ú"_constructor_postprocessor_mappingr…   rz   rl   r   r¼   rÇ   rF   r,   r   r   r   r   r   r    r&   r&   r&   r'   Ú<module>   sH       

ÿ< !0*