ó
    Eñi«!  ã                   óŠ   • S /r SSKrSSKJr  SSKrSSKJr  \(       a  SSKJr	  S r
 SSSSSS	SS
\S\R                  4
S jjrg)Úgeometric_slerpé    N)ÚTYPE_CHECKING)Ú	euclideanc                 óà  • [         R                  " X/5      n[         R                  R                  UR                  5      u  pES[         R
                  " U5      S:¬  -  S-
  nUR                  UR                  S S 2[         R                  4   -  nUR                  UR                  S S 2[         R                  4   -  n[         R                  " X5      n[         R                  R                  U5      n[         R                  " X‡5      n	Uu  p[         R                  " X)-  5      n[         R                  " X)-  5      nXS S 2[         R                  4   -  XS S 2[         R                  4   -  -   $ )Né   r   é   )ÚnpÚvstackÚlinalgÚqrÚTÚdiagÚnewaxisÚdotÚdetÚarctan2ÚsinÚcos)
ÚstartÚendÚtÚbasisÚQÚRÚsignsÚcÚsÚomegas
             Ú[/home/mande/repo/quber/.venv/lib/python3.13/site-packages/scipy/spatial/_geometric_slerp.pyÚ_geometric_slerpr       s  € ä�IŠI�u�lÓ#€EÜ�9‰9�<‰<˜Ÿ™Ó �D€AØ”—’˜“˜q‘Ñ! AÑ%€EØ	�‰ˆe�g‰g’aœŸ™�mÑ$Ñ$€AØ	�‰ˆe�g‰g’aœŸ™�mÑ$Ñ$€Aô 	�ŠˆuÓ€AÜ
�	‰	�‰�aÓ€AÜ�JŠJ�qÓ€Eð �J€EÜ
�Šˆq‰yÓ€AÜ
�Šˆq‰yÓ€AØ’QœŸ
™
�]Ñ#Ñ# cªa´·±¨mÑ,<Ñ&<Ñ<Ð<ó    r   znpt.ArrayLiker   r   ÚtolÚreturnc                 ó   • [         R                  " U [         R                  S9n [         R                  " U[         R                  S9n[         R                  " U5      nUR                  S:”  a  [	        S5      eU R                  S:w  d  UR                  S:w  a  [	        S5      eU R
                  UR
                  :w  a  [	        S5      eU R
                  S:  d  UR
                  S:  a  [	        S5      e[         R                  " X5      (       a!  [         R                  " X UR
                  5      $ X4 HG  n[         R                  " [         R                  R                  U5      SS	S
S9(       a  M>  [	        S5      e   [        U[        5      (       d  [	        S5      e[         R                  " U5      n[        X5      n[         R                  " USS
US9(       a  [        R                   " SSS9  [         R                  " U[         R                  S9nUR
                  S
:X  a"  [         R"                  " S
U R
                  45      $ UR                  S
:X  a/  [%        U U[         R&                  " U5      5      R)                  5       $ [%        U UU5      $ )aÓ  
Geometric spherical linear interpolation.

The interpolation occurs along a unit-radius
great circle arc in arbitrary dimensional space.

Parameters
----------
start : (n_dimensions, ) array-like
    Single n-dimensional input coordinate in a 1-D array-like
    object. `n` must be greater than 1.
end : (n_dimensions, ) array-like
    Single n-dimensional input coordinate in a 1-D array-like
    object. `n` must be greater than 1.
t : float or (n_points,) 1D array-like
    A float or 1D array-like of doubles representing interpolation
    parameters. A common approach is to generate the array
    with ``np.linspace(0, 1, n_pts)`` for linearly spaced points.
    Ascending, descending, and scrambled orders are permitted.

    .. versionchanged:: 1.17.0
        Extrapolation is permitted, allowing values below `0`
        and above `1`.
tol : float
    The absolute tolerance for determining if the start and end
    coordinates are antipodes.

Returns
-------
result : (t.size, D)
    An array of doubles containing the interpolated
    spherical path and including start and
    end when 0 and 1 t are used. The
    interpolated values should correspond to the
    same sort order provided in the t array. The result
    may be 1-dimensional if ``t`` is a float.

Raises
------
ValueError
    If ``start`` or ``end`` are not on the
    unit n-sphere, or for a variety of degenerate conditions.

See Also
--------
scipy.spatial.transform.Slerp : 3-D Slerp that works with quaternions

Notes
-----
The implementation is based on the mathematical formula provided in [1]_,
and the first known presentation of this algorithm, derived from study of
4-D geometry, is credited to Glenn Davis in a footnote of the original
quaternion Slerp publication by Ken Shoemake [2]_.

.. versionadded:: 1.5.0

References
----------
.. [1] https://en.wikipedia.org/wiki/Slerp#Geometric_Slerp
.. [2] Ken Shoemake (1985) Animating rotation with quaternion curves.
       ACM SIGGRAPH Computer Graphics, 19(3): 245-254.

Examples
--------
Interpolate four linearly-spaced values on the circumference of
a circle spanning 90 degrees:

>>> import numpy as np
>>> from scipy.spatial import geometric_slerp
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111)
>>> start = np.array([1, 0])
>>> end = np.array([0, 1])
>>> t_vals = np.linspace(0, 1, 4)
>>> result = geometric_slerp(start,
...                          end,
...                          t_vals)

The interpolated results should be at 30 degree intervals
recognizable on the unit circle:

>>> ax.scatter(result[...,0], result[...,1], c='k')
>>> circle = plt.Circle((0, 0), 1, color='grey')
>>> ax.add_artist(circle)
>>> ax.set_aspect('equal')
>>> plt.show()

Attempting to interpolate between antipodes on a circle is
ambiguous because there are two possible paths, and on a
sphere there are infinite possible paths on the geodesic surface.
Nonetheless, one of the ambiguous paths is returned along
with a warning:

>>> import warnings
>>> opposite_pole = np.array([-1, 0])
>>> with warnings.catch_warnings():
...     warnings.simplefilter("ignore", UserWarning)
...     geometric_slerp(start,
...                     opposite_pole,
...                     t_vals)
array([[ 1.00000000e+00,  0.00000000e+00],
       [ 5.00000000e-01,  8.66025404e-01],
       [-5.00000000e-01,  8.66025404e-01],
       [-1.00000000e+00,  1.22464680e-16]])

Extend the original example to a sphere and plot interpolation
points in 3D:

>>> from mpl_toolkits.mplot3d import proj3d
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111, projection='3d')

Plot the unit sphere for reference (optional):

>>> u = np.linspace(0, 2 * np.pi, 100)
>>> v = np.linspace(0, np.pi, 100)
>>> x = np.outer(np.cos(u), np.sin(v))
>>> y = np.outer(np.sin(u), np.sin(v))
>>> z = np.outer(np.ones(np.size(u)), np.cos(v))
>>> ax.plot_surface(x, y, z, color='y', alpha=0.1)

Interpolating over a larger number of points
may provide the appearance of a smooth curve on
the surface of the sphere, which is also useful
for discretized integration calculations on a
sphere surface:

>>> start = np.array([1, 0, 0])
>>> end = np.array([0, 0, 1])
>>> t_vals = np.linspace(0, 1, 200)
>>> result = geometric_slerp(start,
...                          end,
...                          t_vals)
>>> ax.plot(result[...,0],
...         result[...,1],
...         result[...,2],
...         c='k')
>>> plt.show()

It is also possible to perform extrapolations outside
the interpolation interval by using interpolation parameter
values below 0 or above 1. For example, the above example
may be adjusted to extrapolate to an antipodal position:

>>> fig = plt.figure()
>>> ax = fig.add_subplot(111, projection='3d')
>>> ax.plot_surface(x, y, z, color='y', alpha=0.1)
>>> start = np.array([1, 0, 0])
>>> end = np.array([0, 0, 1])
>>> t_vals = np.linspace(0, 2, 400)
>>> result = geometric_slerp(start,
...                          end,
...                          t_vals)
>>> ax.plot(result[...,0], result[...,1], result[...,2], c='k')
>>> plt.show()
)Údtyper   z:The interpolation parameter value must be one dimensional.z1Start and end coordinates must be one-dimensionalz;The dimensions of start and end must match (have same size)r   zLThe start and end coordinates must both be in at least two-dimensional spaceg      ð?g•Ö&è.>r   )ÚrtolÚatolz(start and end are not on a unit n-sphereztol must be a floatg       @z_start and end are antipodes using the specified tolerance; this may cause ambiguous slerp paths)Ú
stacklevel)r	   ÚasarrayÚfloat64ÚndimÚ
ValueErrorÚsizeÚarray_equalÚlinspaceÚallcloser   ÚnormÚ
isinstanceÚfloatÚfabsr   ÚwarningsÚwarnÚemptyr    Ú
atleast_1dÚravel)r   r   r   r"   ÚcoordÚ
coord_dists         r   r   r   !   s  € ôH �JŠJ�u¤B§J¡JÑ/€EÜ
�*Š*�S¤§
¡
Ñ
+€CÜ
�
Š
�1‹€Aà‡v�v�ƒzÜð :ó ;ð 	;ð ‡z�z�Qƒ˜#Ÿ(™( a›-Üð 3ó 4ð 	4ð ‡z�z�S—X‘XÓÜð ;ó <ð 	<ð ‡z�z�Aƒ~˜Ÿ™ A›Üð !ó "ð 	"ô 
‡~‚~�e×!Ñ!Ü�{Š{˜5¨¯©Ó0Ð0ð “ˆÜ�{Š{œ2Ÿ9™9Ÿ>™>¨%Ó0°#Ø $Ø !÷#ñ #ô ð 3ó 4ð 4ñ	 ô �cœ5×!Ñ!ÜÐ.Ó/Ð/ä�gŠg�c‹lˆä˜5Ó&€Jô 
‡{‚{�:˜s¨°×5Ü�Šð =ð "#ò	$ô
 	�
Š
�1œBŸJ™JÑ'€Aà‡v�v�ƒ{Ü�xŠx˜˜EŸJ™J˜Ó(Ð(à‡v�v�ƒ{Ü Ø #Ü "§¢¨aÓ 0ó2ç27±%³'ð	:ô   Ø #Ø !ó#ð 	#r!   )gH¯¼šò×z>)Ú__all__r5   Útypingr   Únumpyr	   Úscipy.spatial.distancer   Únumpy.typingÚnptr    r3   Úndarrayr   © r!   r   Ú<module>rD      sf   ðØÐ
€ã Ý  ã Ý ,æÝò=ð0 ñ	_#Øð_#à	ð_#ð ð_#ð 
ð	_#ð
 ‡Z�Zö_#r!   