+
    ùª¨j
O  ã                   óÄ   € R t ^ RIt^ RIHtHtHtHtHtHtH	t	H
t
Ht ^ RIHt ^ RIHtHtHtHt ^ RIHu Ht ^RIHtHtHt . ROtR tRR ltRR ltR	 tRR
 lt RR lt!R# )zr
ltisys -- a collection of functions to convert linear time invariant systems
from one representation to another.
N)	Úr_ÚeyeÚ
atleast_2dÚpolyÚdotÚasarrayÚzerosÚarrayÚouter)Úlinalg)Úarray_namespaceÚxp_sizeÚ
xp_promoteÚxp_result_type)Útf2zpkÚzpk2tfÚ	normalizec                óÈ  € \        W4      w  r\        V P                  4      pV^8X  d   \        V .V P                  4      p V P                  ^,          p\        V4      pW48”  d   Rp\        V4      hV^ 8X  g   V^ 8X  d?   \        . \        4      \        . \        4      \        . \        4      \        . \        4      3# \        P                  ! \        P                  ! V P                  ^ ,          WC,
          3V P                  R7      V 34      p V P                  R,          ^ 8”  d   \        V R,          4      pM\        ^ ..\        4      pV^8X  dc   VP                  V P                  4      p\        R4      \        ^VP                  ^,          34      \        VP                  ^ ,          ^34      V3# \        VR,          .4      ) p\        V\        V^,
          V^,
          4      3,          p\        V^,
          ^4      p	V R,          \        V R,          VR,          4      ,
          p
VP                  V
P                  ^ ,          V	P                  ^,          34      pW‰W¦3# )a)  Transfer function to state-space representation.

Parameters
----------
num, den : array_like
    Sequences representing the coefficients of the numerator and
    denominator polynomials, in order of descending degree. The
    denominator needs to be at least as long as the numerator.

Returns
-------
A, B, C, D : ndarray
    State space representation of the system, in controller canonical
    form.

Examples
--------
Convert the transfer function:

.. math:: H(s) = \frac{s^2 + 3s + 3}{s^2 + 2s + 1}

>>> num = [1, 3, 3]
>>> den = [1, 2, 1]

to the state-space representation:

.. math::

    \dot{\textbf{x}}(t) =
    \begin{bmatrix} -2 & -1 \\ 1 & 0 \end{bmatrix} \textbf{x}(t) +
    \begin{bmatrix} 1 \\ 0 \end{bmatrix} \textbf{u}(t) \\

    \textbf{y}(t) = \begin{bmatrix} 1 & 2 \end{bmatrix} \textbf{x}(t) +
    \begin{bmatrix} 1 \end{bmatrix} \textbf{u}(t)

>>> from scipy.signal import tf2ss
>>> A, B, C, D = tf2ss(num, den)
>>> A
array([[-2., -1.],
       [ 1.,  0.]])
>>> B
array([[ 1.],
       [ 0.]])
>>> C
array([[ 1.,  2.]])
>>> D
array([[ 1.]])
z7Improper transfer function. `num` is longer than `den`.©Údtypeºé   NNéÿÿÿÿ©ºNNNé    )r   r   )r   r   )r   ÚlenÚshaper   r   Ú
ValueErrorr	   ÚfloatÚnpÚhstackr   r   Úreshaper   r   r
   )ÚnumÚdenÚnnÚMÚKÚmsgÚDÚfrowÚAÚBÚCs   &&         ÚXC:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\scipy\signal\_lti_conversion.pyÚtf2ssr/      sà  € ôp ˜Ó"�H€CÜ	ˆS�Y‰Y‹€BØ	ˆQ„wÜ�s�e˜SŸY™YÓ'ˆØ�	‰	�!�€AÜˆC‹€AØ„uØGˆÜ˜‹oÐØˆA„v��a”Ü�bœ%Ó ¤%¨¬EÓ"2´E¸"¼eÓ4DÜ�bœ%Ó ð"ð 	"ô �)Š)”R—X’X˜sŸy™y¨�|¨Q­UÐ3¸3¿9¹9ÔEÀsÐKÓ
L€Cà
‡y�y�…}�qÔÜ�s˜4•yÓ!‰ô �A�3�%œÓˆàˆA„vØ�I‰I�c—i‘iÓ ˆä�f“œu a¨¯©°­ _Ó5Ü�q—w‘w˜q•z 1�oÓ&¨ð+ð 	+ô �3�r•7�)ÓÐ€DÜ
ˆ4”�Q˜•U˜A �EÓ"Ð"Õ#€AÜˆA��E�1‹€AØˆE�
”U˜3˜t�9 c¨"¥gÓ.Õ.€AØ	�	‰	�1—7‘7˜1•:˜qŸw™w q�zÐ*Ó+€Aà�ˆ:Ðó    c           	     ó  aa€ V f   Vf   Vf   \        R4      hVf   Vf   \        R4      hVf   Vf   \        R4      h\        WW#4      o\        WW#SRR7      w  rr#\        WW#SR7      oVV3R lWW#3 4       w  rr#V P                  ^ ,          ;'       g/    VP                  ^ ,          ;'       g    VP                  ^,          pVP                  ^,          ;'       g    VP                  ^,          pVP                  ^ ,          ;'       g    VP                  ^ ,          p\        V 4      ^ 8X  d   SP                  WD3SR7      MT p \        V4      ^ 8X  d   SP                  WE3SR7      MTp\        V4      ^ 8X  d   SP                  Wd3SR7      MTp\        V4      ^ 8X  d   SP                  We3SR7      MTpV P                  WD38w  d    \        R	V P                   R
V RV R24      hVP                  WE38w  d    \        RVP                   R
V RV R24      hVP                  Wd38w  d    \        RVP                   R
V RV R24      hVP                  We38w  d    \        RVP                   R
V RV R24      hWW#3# )a™
  Check state-space matrices compatibility and ensure they are 2d arrays.

First, the input matrices are converted into two-dimensional arrays with
appropriate dtype as needed. Then the dimensions n, q, p are determined by
investigating the array shapes. If an input is ``None``, or has size zero, it is
set to an array of zeros of compatible shape. Finally, it is verified that all
parameter shapes are compatible with each other. If that fails, a ``ValueError`` is
raised. Note that the dimensions n, q, p are allowed to be zero.

Parameters
----------
A : array_like, optional
    Two-dimensional array of shape (n, n).
B : array_like, optional
    Two-dimensional array of shape (n, p).
C : array_like, optional
    Two-dimensional array of shape (q, n).
D : array_like, optional
    Two-dimensional array of shape (q, p).

Returns
-------
A, B, C, D : array
    State-space matrices as two-dimensional arrays with identical dtype.
    The result dtype is determined based on the standard
    `dtype promotion rules <https://numpy.org/doc/2.3/reference/arrays.promotion.html>`_
    except for when the inputs are all of integer dtype, in which case the returned
    arrays will have the default floating point dtype of ``float64``.

Raises
------
ValueError
    If the dimensions n, q, or p could not be determined or if the shapes are
    incompatible with each other.

Notes
-----
If a matrix is not modified, the original matrix (not a copy) is returned.

The :ref:`tutorial_signal_state_space_representation` section of the
:ref:`user_guide` presents the corresponding definitions of continuous-time and
disrcete time state space systems.

See Also
--------
StateSpace: Linear Time Invariant system in state-space form.
dlti: Discrete-time linear time invariant system base class.
tf2ss: Transfer function to state-space representation.
ss2tf: State-space to transfer function.
ss2zpk: State-space representation to zero-pole-gain representation.
cont2discrete: Transform a continuous to a discrete state-space system.

Examples
--------
The following example demonstrates that the passed lists are converted into
two-dimensional arrays:

>>> from scipy.signal import abcd_normalize
>>> AA, BB, CC, DD = abcd_normalize(A=[[1, 2], [3, 4]], B=[[-1], [5]],
...                                 C=[[4, 5]], D=2.5)
>>> AA.shape, BB.shape, CC.shape, DD.shape
((2, 2), (2, 1), (1, 2), (1, 1))

In the following, the missing parameter C is assumed to be an array of zeros
with shape (1, 2):

>>> from scipy.signal import abcd_normalize
>>> AA, BB, CC, DD = abcd_normalize(A=[[1, 2], [3, 4]], B=[[-1], [5]], D=2.5)
>>> AA.shape, BB.shape, CC.shape, DD.shape
((2, 2), (2, 1), (1, 2), (1, 1))
>>> CC
array([[0., 0.]])

z9Dimension n is undefined for parameters A = B = C = None!z5Dimension p is undefined for parameters B = D = None!z5Dimension q is undefined for parameters C = D = None!T)ÚxpÚforce_floating)r2   c              3   ó¢   <"  € T FD  pVe)   \         P                  ! SP                  V4      ^SR7      MSP                  RSR7      x € KF  	  R # 5i)N)Úndimr2   r   )r   r   )ÚxpxÚ
atleast_ndr   r   )Ú.0ÚM_r   r2   s   & €€r.   Ú	<genexpr>Ú!abcd_normalize.<locals>.<genexpr>Í   sK   øé € ð ñ ˆBð Š>ô 	�Š�r—z‘z "“~¨A°"Õ5Ø!Ÿx™x¨°e˜xÓ<ô	=ãùs   ƒAAr   zParameter A has shape z but should be (z, z)!zParameter B has shape zParameter C has shape zParameter D has shape )r   r   r   r   r   r   r   )	r+   r,   r-   r)   ÚnÚpÚqr   r2   s	   &&&&   @@r.   Úabcd_normalizer?   v   s]  ù€ ðV 	‚y�Q’Y 1¢9ÜÐTÓUÐUØ‚y�Q’YÜÐPÓQÐQØ‚y�Q’YÜÐPÓQÐQä	˜˜qÓ	$€BÜ˜A !¨2¸dÔC�J€Aˆ!Ü˜1 ¨"Ô-€Eõð ˜‘,ó�J€Aˆ!ð 	
�‰��
×.Ð.�a—g‘g˜a•j×.Ð. A§G¡G¨A¥J€AØ	�‰��
× Ð �a—g‘g˜a•j€AØ	�‰��
× Ð �a—g‘g˜a•j€Aô *1°«°q¬ˆ�‰�!�˜uˆÔ%¸a€AÜ)0°«°q¬ˆ�‰�!�˜uˆÔ%¸a€AÜ)0°«°q¬ˆ�‰�!�˜uˆÔ%¸a€AÜ)0°«°q¬ˆ�‰�!�˜uˆÔ%¸a€Aà‡w�w�1�&ÔÜÐ1°!·'±'°Ð:JÈ1È#ÈRÐPQÈsÐRTÐUÓVÐVØ‡w�w�1�&ÔÜÐ1°!·'±'°Ð:JÈ1È#ÈRÐPQÈsÐRTÐUÓVÐVØ‡w�w�1�&ÔÜÐ1°!·'±'°Ð:JÈ1È#ÈRÐPQÈsÐRTÐUÓVÐVØ‡w�w�1�&ÔÜÐ1°!·'±'°Ð:JÈ1È#ÈRÐPQÈsÐRTÐUÓVÐVà�ˆ:Ðr0   c                óF  € \        WW#4      w  rr#VP                  w  rVWF8¼  d   \        R4      hVRWD^,           13,          pVRWD^,           13,          p \        V 4      pVP                  ^ 8X  dO   VP                  ^ 8X  d>   \
        P                  ! V4      pVP                  ^ 8X  d   V P                  ^ 8X  d   . pW‡3# V P                  ^ ,          p	V R,          VR,          ,           VR,          ,           V,           R,           p
\
        P                  ! WY^,           3V
P                  4      p\        V4       FN  p\        W+R3,          4      p\        V \        W4      ,
          4      W;,          ^,
          V,          ,           W‹&   KP  	  W‡3#   \         d    ^p EL>i ; i)a.  State-space to transfer function.

A, B, C, D defines a linear state-space system with `p` inputs,
`q` outputs, and `n` state variables.

Parameters
----------
A : array_like
    State (or system) matrix of shape ``(n, n)``
B : array_like
    Input matrix of shape ``(n, p)``
C : array_like
    Output matrix of shape ``(q, n)``
D : array_like
    Feedthrough (or feedforward) matrix of shape ``(q, p)``
input : int, optional
    For multiple-input systems, the index of the input to use.

Returns
-------
num : 2-D ndarray
    Numerator(s) of the resulting transfer function(s). `num` has one row
    for each of the system's outputs. Each row is a sequence representation
    of the numerator polynomial.
den : 1-D ndarray
    Denominator of the resulting transfer function(s). `den` is a sequence
    representation of the denominator polynomial.

Notes
-----
Before calculating `num` and `den`, the function `abcd_normalize` is called to
convert the parameters `A`, `B`, `C`, `D` into two-dimesional arrays of the
same dtype. The resulting dtype will be based on NumPy's dtype promotion rules,
except in the case where each of `A`, `B`, `C`, and `D` has integer dtype, in which
case the resulting dtype will be the default floating point dtype of ``float64``.

The :ref:`tutorial_signal_state_space_representation` section of the
:ref:`user_guide` presents the corresponding definitions of continuous-time and
disrcete time state space systems.

Examples
--------
Convert the state-space representation:

.. math::

    \dot{\textbf{x}}(t) =
    \begin{bmatrix} -2 & -1 \\ 1 & 0 \end{bmatrix} \textbf{x}(t) +
    \begin{bmatrix} 1 \\ 0 \end{bmatrix} \textbf{u}(t) \\

    \textbf{y}(t) = \begin{bmatrix} 1 & 2 \end{bmatrix} \textbf{x}(t) +
    \begin{bmatrix} 1 \end{bmatrix} \textbf{u}(t)

>>> A = [[-2, -1], [1, 0]]
>>> B = [[1], [0]]  # 2-D column vector
>>> C = [[1, 2]]    # 2-D row vector
>>> D = 1

to the transfer function:

.. math:: H(s) = \frac{s^2 + 3s + 3}{s^2 + 2s + 1}

>>> from scipy.signal import ss2tf
>>> ss2tf(A, B, C, D)
(array([[1., 3., 3.]]), array([ 1.,  2.,  1.]))
z)System does not have the input specified.r   ç        r   )r   r   )r?   r   r   r   Úsizer    ÚravelÚemptyr   Úranger   r   )r+   r,   r-   r)   ÚinputÚnoutÚninr$   r#   Ú
num_statesÚ	type_testÚkÚCks   &&&&&        r.   Úss2tfrM   é   s^  € ôL    aÓ+�J€Aˆ!à—‘�I€DØ„|ÜÐDÓEÐEð 	
ˆ!ˆU˜1•9ˆ_Ð
Õ€AØ	ˆ!ˆU˜1•9ˆ_Ð
Õ€AðÜ�1‹gˆð 	
�‰�!Œ˜!Ÿ&™& Aœ+Ü�hŠh�q‹kˆØ�F‰F�aŒK˜aŸf™f¨œkØˆCØˆxˆà—‘˜•€JØ�$•˜!˜D�'Õ! A d¥GÕ+¨aÕ/°#Õ5€IÜ
�(Š(�D q�.Ð)¨9¯?©?Ó
;€CÜ�4Ž[ˆÜ˜˜Q˜$�Ó ˆÜ�aœ#˜a›*•nÓ%¨­°­°SÕ(8Õ8ˆ‹ñ ð ˆ8€Oøô! ô Ø‹ðús   ÁF ÆF ÆF c                ó(   € \        \        WV4      !  # )a  Zero-pole-gain representation to state-space representation.

Parameters
----------
z, p : sequence
    Zeros and poles.
k : float
    System gain.

Returns
-------
A, B, C, D : ndarray
    State space representation of the system, in controller canonical
    form.

)r/   r   )Úzr=   rK   s   &&&r.   Úzpk2ssrP   N  s   € ô" ”&˜˜q“/Ñ"Ð"r0   c           
     ó,   € \        \        WW#VR7      !  # )aV  State-space representation to zero-pole-gain representation.

A, B, C, D defines a linear state-space system with `p` inputs,
`q` outputs, and `n` state variables.

Parameters
----------
A : array_like
    State (or system) matrix of shape ``(n, n)``
B : array_like
    Input matrix of shape ``(n, p)``
C : array_like
    Output matrix of shape ``(q, n)``
D : array_like
    Feedthrough (or feedforward) matrix of shape ``(q, p)``
input : int, optional
    For multiple-input systems, the index of the input to use.

Returns
-------
z, p : sequence
    Zeros and poles.
k : float
    System gain.

)rF   )r   rM   )r+   r,   r-   r)   rF   s   &&&&&r.   Úss2zpkrR   b  s   € ô6 ”5˜˜q¨5Ô1Ñ2Ð2r0   c                ón  € \        V R4      '       d/   \        V P                  4      '       d   V P                  WVR7      # \        V 4      ^8X  dY   \	        \        V ^ ,          V ^,          4      WVR7      p\        V^ ,          V^,          V^,          V^,          4      V3,           # \        V 4      ^8X  da   \	        \        V ^ ,          V ^,          V ^,          4      VW#R7      p\        V^ ,          V^,          V^,          V^,          4      V3,           # \        V 4      ^8X  d   V w  rVrxM\        R4      hVR8X  d)   Vf   \        R4      hV^ 8  g   V^8”  d   \        R4      hVR8X  Ed   \        P                  ! VP                  ^ ,          4      W1,          V,          ,
          p	\        P                  ! V	\        P                  ! VP                  ^ ,          4      R	V,
          V,          V,          ,           4      p
\        P                  ! W‘V,          4      p\        P                  ! V	P                  4       VP                  4       4      pVP                  4       pWƒ\        P                   ! W{4      ,          ,           pEM)VR
8X  g   VR8X  d   \	        WRRR7      # VR8X  g   VR8X  d   \	        WRRR7      # VR8X  d   \	        WRR	R7      # VR8X  Ed4   \        P"                  ! WV34      p\        P"                  ! \        P$                  ! VP                  ^,          VP                  ^ ,          34      \        P$                  ! VP                  ^,          VP                  ^,          34      34      p\        P&                  ! Wï34      p\        P(                  ! VV,          4      pVRVP                  ^ ,          1R3,          pVR^ VP                  ^,          13,          p
VRVP                  ^,          R13,          pTpTpEM¡VR8X  Ed   VP                  ^ ,          pVP                  ^,          p\        P*                  ! \        P,                  ! WV.4      V,          \        P                  ! V4      4      p\%        VV^V,          ,           34      p\        P,                  ! V.V..4      p\        P(                  ! V4      pVRV1^ V13,          pVRV1VVV,           13,          pVRV1VV,           R13,          pTp
VV,
          VV,          ,           pTpW‡V,          ,           pM{VR8X  df   \        P.                  ! V^ 4      '       g   \        R4      h\        P(                  ! WQ,          4      p
W¦,          V,          pTpWv,          V,          pM\        RV R24      hW«WÍV3# )aü  
Transform a continuous to a discrete state-space system.

Parameters
----------
system : a tuple describing the system or an instance of `lti`
    The following gives the number of elements in the tuple and
    the interpretation:

    * 1: (instance of `lti`)
    * 2: (num, den)
    * 3: (zeros, poles, gain)
    * 4: (A, B, C, D)

dt : float
    The discretization time step.
method : str, optional
    Which method to use:

    * gbt: generalized bilinear transformation
    * bilinear: Tustin's approximation ("gbt" with alpha=0.5)
    * euler: Euler (or forward differencing) method ("gbt" with alpha=0)
    * backward_diff: Backwards differencing ("gbt" with alpha=1.0)
    * zoh: zero-order hold (default)
    * foh: first-order hold (*versionadded: 1.3.0*)
    * impulse: equivalent impulse response (*versionadded: 1.3.0*)

alpha : float within [0, 1], optional
    The generalized bilinear transformation weighting parameter, which
    should only be specified with method="gbt", and is ignored otherwise

Returns
-------
sysd : tuple containing the discrete system
    Based on the input type, the output will be of the form

    * (num, den, dt)   for transfer function input
    * (zeros, poles, gain, dt)   for zeros-poles-gain input
    * (A, B, C, D, dt) for state-space system input

Notes
-----
By default, the routine uses a Zero-Order Hold (zoh) method to perform
the transformation. Alternatively, a generalized bilinear transformation
may be used, which includes the common Tustin's bilinear approximation,
an Euler's method technique, or a backwards differencing technique.

The Zero-Order Hold (zoh) method is based on [1]_, the generalized bilinear
approximation is based on [2]_ and [3]_, the First-Order Hold (foh) method
is based on [4]_.

References
----------
.. [1] https://en.wikipedia.org/wiki/Discretization#Discretization_of_linear_state_space_models

.. [2] http://techteach.no/publications/discretetime_signals_systems/discrete.pdf

.. [3] G. Zhang, X. Chen, and T. Chen, Digital redesign via the generalized
    bilinear transformation, Int. J. Control, vol. 82, no. 4, pp. 741-754,
    2009.
    (https://www.mypolyuweb.hk/~magzhang/Research/ZCC09_IJC.pdf)

.. [4] G. F. Franklin, J. D. Powell, and M. L. Workman, Digital control
    of dynamic systems, 3rd ed. Menlo Park, Calif: Addison-Wesley,
    pp. 204-206, 1998.

Examples
--------
We can transform a continuous state-space system to a discrete one:

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.signal import cont2discrete, lti, dlti, dstep

Define a continuous state-space system.

>>> A = np.array([[0, 1],[-10., -3]])
>>> B = np.array([[0],[10.]])
>>> C = np.array([[1., 0]])
>>> D = np.array([[0.]])
>>> l_system = lti(A, B, C, D)
>>> t, x = l_system.step(T=np.linspace(0, 5, 100))
>>> fig, ax = plt.subplots()
>>> ax.plot(t, x, label='Continuous', linewidth=3)

Transform it to a discrete state-space system using several methods.

>>> dt = 0.1
>>> for method in ['zoh', 'bilinear', 'euler', 'backward_diff', 'foh', 'impulse']:
...    d_system = cont2discrete((A, B, C, D), dt, method=method)
...    s, x_d = dstep(d_system)
...    ax.step(s, np.squeeze(x_d), label=method, where='post')
>>> ax.axis([t[0], t[-1], x[0], 1.4])
>>> ax.legend(loc='best')
>>> fig.tight_layout()
>>> plt.show()

Úto_discrete)ÚdtÚmethodÚalpha)rV   rW   zKFirst argument must either be a tuple of 2 (tf), 3 (zpk), or 4 (ss) arrays.ÚgbtNzUAlpha parameter must be specified for the generalized bilinear transform (gbt) methodzDAlpha parameter must be within the interval [0,1] for the gbt methodg      ð?ÚbilinearÚtusting      à?ÚeulerÚforward_diffrA   Úbackward_diffÚzohr   ÚfohÚimpulsez<Impulse method is only applicable to strictly proper systemszUnknown transformation method 'Ú')ÚhasattrÚcallablerT   r   Úcont2discreter/   rM   rP   rR   r   r    r   r   r   ÚsolveÚ	transposer   r!   r   ÚvstackÚexpmÚ
block_diagÚblockÚallclose)ÚsystemrU   rV   rW   ÚsysdÚaÚbÚcÚdÚimaÚadÚbdÚcdÚddÚem_upperÚem_lowerÚemÚmsr<   ÚmÚms11Úms12Úms13s   &&&&                   r.   rd   rd   €  s®  € ôF ˆv�}×%Ò%¬(°6×3EÑ3E×*FÒ*FØ×!Ñ! R¸eÐ!ÓDÐDä
ˆ6ƒ{�aÔÜœU 6¨!¥9¨f°Q­iÓ8¸"Ø#(ô*ˆä�T˜!•W˜d 1�g t¨A¥w°°QµÓ8¸B¸5Õ@Ð@Ü	ˆV‹˜Ô	ÜœV F¨1¥I¨v°a­y¸&À½)ÓDÀbØ$*ô9ˆä�d˜1•g˜t A�w¨¨Q­°°aµÓ9¸R¸EÕAÐAÜ	ˆV‹˜Ô	Ø‰
ˆˆa�äð 6ó 7ð 	7ð �„ØŠ=Üð Kó Lð Là�QŒY˜% !œ)Üð 8ó 9ð 9ð �…ä�fŠf�Q—W‘W˜Q•ZÓ  5¥8¨A¥:Õ-ˆÜ�\Š\˜#œrŸvšv a§g¡g¨a¥jÓ1°S¸µYÀµNÀ1Õ4DÕDÓEˆÜ�\Š\˜# !�tÓ$ˆô �\Š\˜#Ÿ-™-›/¨1¯;©;«=Ó9ˆØ�\‰\‹^ˆØ”r—v’v˜a“}Õ$Õ$Šà	�:Ô	 ¨8Ô!3Ü˜V°¸SÔAÐAà	�7Ô	˜f¨Ô6Ü˜V°¸SÔAÐAà	�?Ô	"Ü˜V°¸SÔAÐAà	�5�ä—9’9˜a˜VÓ$ˆô —9’9œbŸhšh¨¯©°­
°A·G±G¸AµJÐ'?Ó@Ü Ÿhšh¨¯©°­
°A·G±G¸AµJÐ'?Ó@ðBó Cˆô �YŠY˜Ð+Ó,ˆÜ�[Š[˜˜b�Ó!ˆð ��—‘˜•�˜Q�Õˆà��1�Q—W‘W˜Q•Z�<�Õ ˆØ��1—7‘7˜1•:‘;�ÕˆàˆØŠà	�5�à�G‰G�A�JˆØ�G‰G�A�Jˆô ×$Ò$¤R§X¢X¨q¨fÓ%5¸Õ%:¼B¿FºFÀ1»IÓFˆÜ˜!˜Q  Q¥�Y˜Ó(ˆÜ�XŠX˜�z H :Ð.Ó/ˆä�[Š[˜‹_ˆð �"�1�"�a˜�c�'�{ˆØ�"�1�"�a˜˜A��g�+�ˆØ�"�1�"�a˜!•e‘f�*�~ˆàˆØ�D�[˜4 $�;Õ&ˆØˆØ�T•�\‰à	�9Ô	Ü�{Š{˜1˜a× Ò Üð :ó ;ð ;ô �[Š[˜�Ó ˆØ�V�b�[ˆØˆØ�U�R�Z‰ô Ð:¸6¸(À!ÐDÓEÐEà�2˜2ÐÐr0   )r/   r?   rM   rP   rR   rd   )NNNN)r   )r^   N)"Ú__doc__Únumpyr    r   r   r   r   r   r   r   r	   r
   Úscipyr   Úscipy._lib._array_apir   r   r   r   Úscipy._external.array_api_extraÚ	_externalÚarray_api_extrar6   Ú_filter_designr   r   r   Ú__all__r/   r?   rM   rP   rR   rd   © r0   r.   Ú<module>r‰      sc   ðñó
 ÷1÷ 1õ 1å ÷3ó 3ç -Ð -ß 5Ñ 5ò€ò^ôBpôfbòJ#ô(3ö<Gr0   