o
    §ƒðj^<  ã                   @   sà   d dl mZ d dlmZ d dlmZ d dlmZmZ d dl	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d„Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zddœd d!„Z dS )#é    )Ú
CoordSys3D)ÚDel)Ú
BaseScalar)ÚVectorÚ
BaseVector)ÚgradientÚcurlÚ
divergence)Údiff)ÚS)Ú	integrate)Úsympify)ÚDyadicNFc              	   C   sÖ  | dt jfv r	| S t|tƒstdƒ‚t| t ƒro|durtdƒ‚|rCdd„ |  tt¡D ƒ|h }i }|D ]
}| 	| 
|¡¡ q3|  |¡} t j}|  ¡ }|D ] }	|	|krf| |	¡||	  |	¡ }
|t|
|ƒ7 }qL|||	 7 }qL|S t| tƒr±|du rz|}t|tƒsƒtdƒ‚tj}|}| j ¡ D ]!\}}|t|||d�t|jd ||d�t|jd	 ||d�B  7 }q�|S |dur¹tdƒ‚|rétƒ }t| ƒ} |  t¡D ]}	|	j|krÔ| |	j¡ qÇi }|D ]
}| 	| 
|¡¡ qÙ|  |¡S | S )
aK  
    Global function for 'express' functionality.

    Re-expresses a Vector, Dyadic or scalar(sympyfiable) in the given
    coordinate system.

    If 'variables' is True, then the coordinate variables (base scalars)
    of other coordinate systems present in the vector/scalar field or
    dyadic are also substituted in terms of the base scalars of the
    given system.

    Parameters
    ==========

    expr : Vector/Dyadic/scalar(sympyfiable)
        The expression to re-express in CoordSys3D 'system'

    system: CoordSys3D
        The coordinate system the expr is to be expressed in

    system2: CoordSys3D
        The other coordinate system required for re-expression
        (only for a Dyadic Expr)

    variables : boolean
        Specifies whether to substitute the coordinate variables present
        in expr, in terms of those of parameter system

    Examples
    ========

    >>> from sympy.vector import CoordSys3D
    >>> from sympy import Symbol, cos, sin
    >>> N = CoordSys3D('N')
    >>> q = Symbol('q')
    >>> B = N.orient_new_axis('B', q, N.k)
    >>> from sympy.vector import express
    >>> express(B.i, N)
    (cos(q))*N.i + (sin(q))*N.j
    >>> express(N.x, B, variables=True)
    B.x*cos(q) - B.y*sin(q)
    >>> d = N.i.outer(N.i)
    >>> express(d, B, N) == (cos(q))*(B.i|N.i) + (-sin(q))*(B.j|N.i)
    True

    r   z>system should be a CoordSys3D                         instanceNzJsystem2 should not be provided for                                 Vectorsc                 S   s   h | ]}|j ’qS © )Úsystem)Ú.0Úxr   r   ú˜/tmp/claude-1000/-var-www-html-academy/3f42efd1-c2b7-4d08-9b05-30d86bb35479/scratchpad/piper/venv/lib/python3.10/site-packages/sympy/vector/functions.pyÚ	<setcomp>L   s    zexpress.<locals>.<setcomp>zCsystem2 should be a CoordSys3D                             instance©Ú	variablesé   )r   ÚzeroÚ
isinstancer   Ú	TypeErrorÚ
ValueErrorÚatomsr   r   ÚupdateÚ
scalar_mapÚsubsÚseparateÚrotation_matrixÚ	to_matrixÚmatrix_to_vectorr   Ú
componentsÚitemsÚexpressÚargsÚsetr   r   Úadd)Úexprr   Úsystem2r   Úsystem_listÚ	subs_dictÚfÚoutvecÚpartsr   ÚtempÚoutdyadÚvarÚkÚvÚ
system_setr   r   r   r&      sb   0




ÿÿ
€
r&   c                 C   sÒ   ddl m} || ƒ}t|ƒdkr^tt|ƒƒ}t| |dd�} | ¡ \}}}| ¡ \}}}	t 	||¡t
| |ƒ }
|
t 	||¡t
| |ƒ 7 }
|
t 	||¡t
| |	ƒ 7 }
|
dkr\t| tƒr\tj}
|
S t| tƒrftjS tjS )aé  
    Returns the directional derivative of a scalar or vector field computed
    along a given vector in coordinate system which parameters are expressed.

    Parameters
    ==========

    field : Vector or Scalar
        The scalar or vector field to compute the directional derivative of

    direction_vector : Vector
        The vector to calculated directional derivative along them.


    Examples
    ========

    >>> from sympy.vector import CoordSys3D, directional_derivative
    >>> R = CoordSys3D('R')
    >>> f1 = R.x*R.y*R.z
    >>> v1 = 3*R.i + 4*R.j + R.k
    >>> directional_derivative(f1, v1)
    R.x*R.y + 4*R.x*R.z + 3*R.y*R.z
    >>> f2 = 5*R.x**2*R.z
    >>> directional_derivative(f2, v1)
    5*R.x**2 + 30*R.x*R.z

    r   )Ú_get_coord_systemsTr   )Úsympy.vector.operatorsr7   ÚlenÚnextÚiterr&   Úbase_vectorsÚbase_scalarsr   Údotr
   r   r   r   ÚZero)ÚfieldÚdirection_vectorr7   Ú	coord_sysÚiÚjr4   r   ÚyÚzÚoutr   r   r   Údirectional_derivative~   s    
rH   c                 C   s:   t ƒ }| jrtt| ƒƒtt| ƒƒ  ¡ S | || ƒ¡ ¡ S )a!  
    Return the laplacian of the given field computed in terms of
    the base scalars of the given coordinate system.

    Parameters
    ==========

    expr : SymPy Expr or Vector
        expr denotes a scalar or vector field.

    Examples
    ========

    >>> from sympy.vector import CoordSys3D, laplacian
    >>> R = CoordSys3D('R')
    >>> f = R.x**2*R.y**5*R.z
    >>> laplacian(f)
    20*R.x**2*R.y**3*R.z + 2*R.y**5*R.z
    >>> f = R.x**2*R.i + R.y**3*R.j + R.z**4*R.k
    >>> laplacian(f)
    2*R.i + 6*R.y*R.j + 12*R.z**2*R.k

    )r   Ú	is_Vectorr   r	   r   Údoitr>   )r*   Údelopr   r   r   Ú	laplacian¯   s   rL   c                 C   s2   t | tƒs	tdƒ‚| tjkrdS t| ƒ ¡ tjkS )aŸ  
    Checks if a field is conservative.

    Parameters
    ==========

    field : Vector
        The field to check for conservative property

    Examples
    ========

    >>> from sympy.vector import CoordSys3D
    >>> from sympy.vector import is_conservative
    >>> R = CoordSys3D('R')
    >>> is_conservative(R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k)
    True
    >>> is_conservative(R.z*R.j)
    False

    úfield should be a VectorT)r   r   r   r   r   Úsimplify©r@   r   r   r   Úis_conservativeÎ   ó
   

rP   c                 C   s2   t | tƒs	tdƒ‚| tjkrdS t| ƒ ¡ tju S )a—  
    Checks if a field is solenoidal.

    Parameters
    ==========

    field : Vector
        The field to check for solenoidal property

    Examples
    ========

    >>> from sympy.vector import CoordSys3D
    >>> from sympy.vector import is_solenoidal
    >>> R = CoordSys3D('R')
    >>> is_solenoidal(R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k)
    True
    >>> is_solenoidal(R.y * R.j)
    False

    rM   T)r   r   r   r   r	   rN   r   r?   rO   r   r   r   Úis_solenoidalï   rQ   rR   c                 C   s¼   t | ƒstdƒ‚| tjkrtjS t|tƒstdƒ‚t	| |dd�} | 
¡ }| ¡ }t|  |d ¡|d ƒ}t|dd… ƒD ]\}}t|||d  ƒ}|  |¡| }|t|||d  ƒ7 }q<|S )aÃ  
    Returns the scalar potential function of a field in a given
    coordinate system (without the added integration constant).

    Parameters
    ==========

    field : Vector
        The vector field whose scalar potential function is to be
        calculated

    coord_sys : CoordSys3D
        The coordinate system to do the calculation in

    Examples
    ========

    >>> from sympy.vector import CoordSys3D
    >>> from sympy.vector import scalar_potential, gradient
    >>> R = CoordSys3D('R')
    >>> scalar_potential(R.k, R) == R.z
    True
    >>> scalar_field = 2*R.x**2*R.y*R.z
    >>> grad_field = gradient(scalar_field)
    >>> scalar_potential(grad_field, R)
    2*R.x**2*R.y*R.z

    zField is not conservativeúcoord_sys must be a CoordSys3DTr   r   r   N)rP   r   r   r   r   r?   r   r   r   r&   r<   r=   r   r>   Ú	enumerater
   )r@   rB   Ú
dimensionsÚscalarsÚtemp_functionrC   ÚdimÚpartial_diffr   r   r   Úscalar_potential  s   

rZ   c                 C   s¸   t |tƒs	tdƒ‚t | tƒrt| |ƒ}n| }|j}t| |¡|dd�}t| |¡|dd�}i }i }	| ¡ }
t	| 
¡ ƒD ]\}}| |¡||
| < | |¡|	|
| < q;| |	¡| |¡ S )a)  
    Returns the scalar potential difference between two points in a
    certain coordinate system, wrt a given field.

    If a scalar field is provided, its values at the two points are
    considered. If a conservative vector field is provided, the values
    of its scalar potential function at the two points are used.

    Returns (potential at point2) - (potential at point1)

    The position vectors of the two Points are calculated wrt the
    origin of the coordinate system provided.

    Parameters
    ==========

    field : Vector/Expr
        The field to calculate wrt

    coord_sys : CoordSys3D
        The coordinate system to do the calculations in

    point1 : Point
        The initial Point in given coordinate system

    position2 : Point
        The second Point in the given coordinate system

    Examples
    ========

    >>> from sympy.vector import CoordSys3D
    >>> from sympy.vector import scalar_potential_difference
    >>> R = CoordSys3D('R')
    >>> P = R.origin.locate_new('P', R.x*R.i + R.y*R.j + R.z*R.k)
    >>> vectfield = 4*R.x*R.y*R.i + 2*R.x**2*R.j
    >>> scalar_potential_difference(vectfield, R, R.origin, P)
    2*R.x**2*R.y
    >>> Q = R.origin.locate_new('O', 3*R.i + R.j + 2*R.k)
    >>> scalar_potential_difference(vectfield, R, P, Q)
    -2*R.x**2*R.y + 18

    rS   Tr   )r   r   r   r   rZ   Úoriginr&   Úposition_wrtr=   rT   r<   r>   r   )r@   rB   Úpoint1Úpoint2Ú	scalar_fnr[   Ú	position1Ú	position2Ú
subs_dict1Ú
subs_dict2rV   rC   r   r   r   r   Úscalar_potential_differenceC  s&   
-
ÿÿrd   c                 C   s4   t j}| ¡ }t| ƒD ]\}}||||  7 }q|S )aà  
    Converts a vector in matrix form to a Vector instance.

    It is assumed that the elements of the Matrix represent the
    measure numbers of the components of the vector along basis
    vectors of 'system'.

    Parameters
    ==========

    matrix : SymPy Matrix, Dimensions: (3, 1)
        The matrix to be converted to a vector

    system : CoordSys3D
        The coordinate system the vector is to be defined in

    Examples
    ========

    >>> from sympy import ImmutableMatrix as Matrix
    >>> m = Matrix([1, 2, 3])
    >>> from sympy.vector import CoordSys3D, matrix_to_vector
    >>> C = CoordSys3D('C')
    >>> v = matrix_to_vector(m, C)
    >>> v
    C.i + 2*C.j + 3*C.k
    >>> v.to_matrix(C) == m
    True

    )r   r   r<   rT   )Úmatrixr   r/   ÚvectsrC   r   r   r   r   r#   ˆ  s
    r#   c                 C   s¸   | j |j krtdt| ƒ d t|ƒ ƒ‚g }|}|jdur*| |¡ |j}|jdus| |¡ t|ƒ}g }| }||vrG| |¡ |j}||vs;t|ƒ}| || |¡dd… ¡ ||fS )z¿
    Calculates the 'path' of objects starting from 'from_object'
    to 'to_object', along with the index of the first common
    ancestor in the tree.

    Returns (index, list) tuple.
    z!No connecting path found between z and Néÿÿÿÿ)	Ú_rootr   ÚstrÚ_parentÚappendr(   r9   ÚextendÚindex)Úfrom_objectÚ	to_objectÚ
other_pathÚobjÚ
object_setÚ	from_pathrm   r   r   r   Ú_path¯  s2   	ÿÿÿ


þ

þrt   )Úorthonormalc                 G   sˆ   t dd„ |D ƒƒstdƒ‚g }t|ƒD ]%\}}t|ƒD ]}|||  || ¡8 }q| tj¡r3tdƒ‚| 	|¡ q| rBdd„ |D ƒ}|S )aO  
    Takes a sequence of independent vectors and orthogonalizes them
    using the Gram - Schmidt process. Returns a list of
    orthogonal or orthonormal vectors.

    Parameters
    ==========

    vlist : sequence of independent vectors to be made orthogonal.

    orthonormal : Optional parameter
                  Set to True if the vectors returned should be
                  orthonormal.
                  Default: False

    Examples
    ========

    >>> from sympy.vector.coordsysrect import CoordSys3D
    >>> from sympy.vector.functions import orthogonalize
    >>> C = CoordSys3D('C')
    >>> i, j, k = C.base_vectors()
    >>> v1 = i + 2*j
    >>> v2 = 2*i + 3*j
    >>> orthogonalize(v1, v2)
    [C.i + 2*C.j, 2/5*C.i + (-1/5)*C.j]

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Gram-Schmidt_process

    c                 s   s   � | ]}t |tƒV  qd S )N)r   r   ©r   Úvecr   r   r   Ú	<genexpr>ð  s   € z orthogonalize.<locals>.<genexpr>z#Each element must be of Type Vectorz#Vector set not linearly independentc                 S   s   g | ]}|  ¡ ‘qS r   )Ú	normalizerv   r   r   r   Ú
<listcomp>ÿ  s    z!orthogonalize.<locals>.<listcomp>)
Úallr   rT   ÚrangeÚ
projectionÚequalsr   r   r   rk   )ru   ÚvlistÚortho_vlistrC   ÚtermrD   r   r   r   ÚorthogonalizeÍ  s   #r‚   )NF)!Úsympy.vector.coordsysrectr   Úsympy.vector.deloperatorr   Úsympy.vector.scalarr   Úsympy.vector.vectorr   r   r8   r   r   r	   Úsympy.core.functionr
   Úsympy.core.singletonr   Úsympy.integrals.integralsr   Ú
sympy.corer   Úsympy.vector.dyadicr   r&   rH   rL   rP   rR   rZ   rd   r#   rt   r‚   r   r   r   r   Ú<module>   s(    
q1!!3E'