
    wg<                         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lmZ ddZd Zd Zd Zd Zd Zd Zd Z d Z!dddZ"y)    )
CoordSys3D)Del)
BaseScalar)Vector
BaseVector)gradientcurl
divergence)diff)S)	integrate)simplify)sympify)DyadicNFc           	      
   | dt         j                  fv r| S t        |t              st	        d      t        | t               r|t        d      |rp| j                  t        t              D ch c]  }|j                   c}|hz
  }i }|D ]"  }|j                  |j                  |             $ | j                  |      } t         j                  }| j                         }	|	D ]E  }||k7  r6|j                  |      |	|   j                  |      z  }
|t!        |
|      z  }>||	|   z  }G |S t        | t"              r||}t        |t              st	        d      t"        j                  }|}| j$                  j'                         D ]N  \  }}|t)        |||      t)        |j*                  d   ||      t)        |j*                  d   ||      z  z  z  }P |S |t        d      |rt-               }t/        |       } | j                  t              D ]-  }|j                  |k7  s|j1                  |j                         / i }|D ]"  }|j                  |j                  |             $ | j                  |      S | S c c}w )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                         instancezJsystem2 should not be provided for                                 VectorszCsystem2 should be a CoordSys3D                             instance	variables   )r   zero
isinstancer   	TypeError
ValueErroratomsr   r   systemupdate
scalar_mapsubsseparaterotation_matrix	to_matrixmatrix_to_vectorr   
componentsitemsexpressargssetr   add)exprr   system2r   xsystem_list	subs_dictfoutvecpartstempoutdyadvarkv
system_sets                   [/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/vector/functions.pyr$   r$      s   ` 6;;fj) " # 	# $ ) * *  .2ZZ
J-OP188PTZS[[KI  7  f!56799Y'D 	#AF{--a0583E3Ea3HH*488%("	# 	D&	!?G':. & ' '++OO))+ 	FDAq6S9 FcB GsCDE FG	F
   ) * *J4=DZZ
+ -88v%NN188,- I 7  f!56799Y''_ Qs   -J c                 Z   ddl m}  ||       }t        |      dkD  rt        t	        |            }t        | |d      } |j                         \  }}}|j                         \  }}}	t        j                  ||      t        | |      z  }
|
t        j                  ||      t        | |      z  z  }
|
t        j                  ||      t        | |	      z  z  }
|
dk(  r t        | t              rt        j                  }
|
S t        | t              rt        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.operatorsr8   lennextiterr$   base_vectorsbase_scalarsr   dotr   r   r   r   Zero)fielddirection_vectorr8   	coord_sysijr3   r*   yzouts              r6   directional_derivativerI      s    : :"5)I
9~i)	yD9((*1a((*1ajj)1-UA>vzz*A.eQ??vzz*A.eQ??!8
5&1++C
	E6	"{{vv    c                     t               }| j                  r7t        t        |             t	        t	        |             z
  j                         S |j                   ||             j                         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(   delops     r6   	laplacianrO      sU    2 EE~~D)*T$t*-==CCEE99U4[!&&((rJ   c                     t        | t              st        d      | t        j                  k(  ryt	        |       j                         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	   r   rA   s    r6   is_conservativerS      sE    4 eV$233;!V[[00rJ   c                     t        | t              st        d      | t        j                  k(  ryt	        |       j                         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

    rQ   T)r   r   r   r   r
   r   r   r@   rR   s    r6   is_solenoidalrU      sF    4 eV$233e%%'16611rJ   c                    t        |       st        d      | t        j                  k(  rt        j
                  S t        |t              st        d      t        | |d      } |j                         }|j                         }t        | j                  |d         |d         }t        |dd       D ]@  \  }}t        |||dz            }| j                  |      |z
  }|t        |||dz            z  }B |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)rS   r   r   r   r   r@   r   r   r   r$   r=   r>   r   r?   	enumerater   )rA   rC   
dimensionsscalarstemp_functionrD   dimpartial_diffs           r6   scalar_potentialr^     s    > 5!455vv i,899E95E'')J$$&Geii
16
CMJqrN+ A3M71q5>:yy~4<Q@@A rJ   c                    t        |t              st        d      t        | t              rt	        | |      }n| }|j
                  }t        |j                  |      |d      }t        |j                  |      |d      }i }i }	|j                         }
t        |j                               D ]3  \  }}|j                  |      ||
|   <   |j                  |      |	|
|   <   5 |j                  |	      |j                  |      z
  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

    rW   Tr   )r   r   r   r   r^   originr$   position_wrtr>   rX   r=   r?   r   )rA   rC   point1point2	scalar_fnr`   	position1	position2
subs_dict1
subs_dict2rZ   rD   r*   s                r6   scalar_potential_differenceri   D  s   Z i,899% $UI6	 	F++F3Y"&(I++F3Y"&(I JJ$$&G)0023 21!"y!1
71:!"y!1
71:2 >>*%	z(BBBrJ   c                     t         j                  }|j                         }t        |       D ]  \  }}||||   z  z  } |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=   rX   )matrixr   r.   vectsrD   r*   s         r6   r!   r!     sK    @ [[F!E&! 1!eAh,MrJ   c                    | j                   |j                   k7  r&t        dt        |       z   dz   t        |      z         g }|}|j                  *|j	                  |       |j                  }|j                  *|j	                  |       t        |      }g }| }||vr"|j	                  |       |j                  }||vr"t        |      }|j                  |      }|dk\  r|j	                  ||          |dz  }|dk\  r||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 r   r   )_rootr   str_parentappendr&   r:   index)from_object	to_object
other_pathobj
object_set	from_pathrr   rD   s           r6   _pathry     s"    IOO+<[)*,3469)nE F 	F J
C
++
!#kk ++
! cZJI
C
Z
kk Z
 	NEA
q&A'	Q q& )rJ   )orthonormalc                    t        d |D              st        d      g }t        |      D ]s  \  }}t        |      D ]  }|||   j	                  ||         z  } t        |      j                  t        j                        rt        d      |j                  |       u | r|D cg c]  }|j                          }}|S c c}w )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              3   <   K   | ]  }t        |t                y w)N)r   r   ).0vecs     r6   	<genexpr>z orthogonalize.<locals>.<genexpr>  s     83z#v&8s   z#Each element must be of Type Vectorz#Vector set not linearly independent)allr   rX   range
projectionr   equalsr   r   r   rq   	normalize)rz   vlistortho_vlistrD   termrE   r~   s          r6   orthogonalizer     s    F 8%88=>>KU# !4q 	8AKN--eAh77D	8
 D>  -BCC4 ! 2=>3s}}>> ?s   'C)NF)#sympy.vector.coordsysrectr   sympy.vector.deloperatorr   sympy.vector.scalarr   sympy.vector.vectorr   r   r9   r   r	   r
   sympy.core.functionr   sympy.core.singletonr   sympy.integrals.integralsr   sympy.simplify.simplifyr   
sympy.corer   sympy.vector.dyadicr   r$   rI   rO   rS   rU   r^   ri   r!   ry   r    rJ   r6   <module>r      sk    0 ( * 2 = = $ " / ,  &nb.b)>1B2B0fBCJ$NB ', 4rJ   