Ë
    täiû3  ã                   óô   — d dl mZ d dlmZmZmZmZmZ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mZmZ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„Z%d„ Z& G d„ de«      Z'y)é    )ÚAccumBounds)ÚSÚSymbolÚAddÚsympifyÚExprÚ	PoleErrorÚMul)Úfactor_terms)ÚFloatÚ_illegal)ÚAppliedUndef)ÚDummy)Ú	factorial)ÚAbsÚsignÚargÚre)ÚexpÚlog)Úgamma)ÚPolynomialErrorÚfactor)ÚOrderé   )Úgruntzc                 ó>   — t        | |||«      j                  d¬«      S )aQ  Computes the limit of ``e(z)`` at the point ``z0``.

    Parameters
    ==========

    e : expression, the limit of which is to be taken

    z : symbol representing the variable in the limit.
        Other symbols are treated as constants. Multivariate limits
        are not supported.

    z0 : the value toward which ``z`` tends. Can be any expression,
        including ``oo`` and ``-oo``.

    dir : string, optional (default: "+")
        The limit is bi-directional if ``dir="+-"``, from the right
        (z->z0+) if ``dir="+"``, and from the left (z->z0-) if
        ``dir="-"``. For infinite ``z0`` (``oo`` or ``-oo``), the ``dir``
        argument is determined from the direction of the infinity
        (i.e., ``dir="-"`` for ``oo``).

    Examples
    ========

    >>> from sympy import limit, sin, oo
    >>> from sympy.abc import x
    >>> limit(sin(x)/x, x, 0)
    1
    >>> limit(1/x, x, 0) # default dir='+'
    oo
    >>> limit(1/x, x, 0, dir="-")
    -oo
    >>> limit(1/x, x, 0, dir='+-')
    zoo
    >>> limit(1/x, x, oo)
    0

    Notes
    =====

    First we try some heuristics for easy and frequent cases like "x", "1/x",
    "x**2" and similar, so that it's fast. For all other cases, we use the
    Gruntz algorithm (see the gruntz() function).

    See Also
    ========

     limit_seq : returns the limit of a sequence.
    F)Údeep)ÚLimitÚdoit)ÚeÚzÚz0Údirs       úb/Volumes/fast/ai/experiments/MLX_z-image/.venv/lib/python3.12/site-packages/sympy/series/limits.pyÚlimitr&      s$   € ôf ��A�r˜3Ó×$Ñ$¨%Ð$Ó0Ð0ó    c                 ó„  — d}|t         j                  u rBt        | j                  |d|z  «      |t         j                  d«      }t        |t        «      ry|S | j                  s6| j                  s*| j                  s| j                  �r)t        | t        «      �sg }ddlm} | j                  D ]ä  }t        ||||«      }|j                  t         j                  «      r~|j                   €rt        | t"        «      r`t%        | «      }	t        |	t&        «      s ||	«      }	t        |	t&        «      st)        | «      }	t        |	t&        «      rt+        |	|||«      c S  y yt        |t        «      r y|t         j,                  u r y|j/                  |«       Œæ |�r | j0                  |Ž }|t         j,                  u r²| j                  r¦t3        d„ |D «       «      r”g }
g }t5        |«      D ]E  \  }}t        |t6        «      r|
j/                  |«       Œ(|j/                  | j                  |   «       ŒG t9        |«      dkD  r/t'        |Ž j;                  «       }t        ||||«      }|t'        |
Ž z  }|t         j,                  u r5	 ddlm}  || «      }|t         j,                  u s|| k(  ryt        ||||«      S |S # t@        $ r Y yw xY w)a+  Computes the limit of an expression term-wise.
    Parameters are the same as for the ``limit`` function.
    Works with the arguments of expression ``e`` one by one, computing
    the limit of each and then combining the results. This approach
    works only for simple limits, but it is fast.
    Nr   Ú+r   )Útogetherc              3   ó<   K  — | ]  }t        |t        «      –— Œ y ­w©N)Ú
isinstancer   )Ú.0Úrrs     r%   Ú	<genexpr>zheuristics.<locals>.<genexpr>j   s   è ø€ Ð/XÑVWÐPR´
¸2¼{×0KÑVWùs   ‚)Úratsimp)!r   ÚInfinityr&   ÚsubsÚZeror-   r   Úis_MulÚis_AddÚis_PowÚis_Functionr   Úsympy.simplify.simplifyr*   ÚargsÚhasÚ	is_finiter   r   r
   r   Ú
heuristicsÚNaNÚappendÚfuncÚanyÚ	enumerater   ÚlenÚsimplifyÚsympy.simplify.ratsimpr1   r   )r!   r"   r#   r$   ÚrvÚrr*   ÚaÚlÚmÚr2Úe2ÚiiÚrvalÚe3r1   Úrat_es                    r%   r=   r=   E   sB  € ð 
€BØ	ŒQ�Z‰ZÑÜ�1—6‘6˜!˜Q˜q™S“> 1¤a§f¡f¨cÓ2ˆÜ�bœ%Ô Øð` €Ið_ �(Š(�a—h’h !§(¢(¨q¯}«}ÄZÐPQÔS_ÕE`ØˆÝ4Ø—”ˆAÜ�a˜˜B Ó$ˆAØ�u‰u”Q—Z‘ZÔ  Q§[¡[Ð%8Ü˜a¤Ô%Ü$ Q›�AÜ% a¬Ô-Ù$ Q›K˜Ü% a¬Ô-Ü" 1›I˜Ü! !¤SÔ)Ü)¨!¨Q°°CÓ8Ò8ÙÙÜ˜AœuÔ%ÙØ”a—e‘e‘Ùà—‘˜•ð% ò& Ø�—‘˜�ˆBØ”Q—U‘U‰{˜qŸxšx¬CÑ/XÑVWÓ/XÔ,XØ�Ø�Ü )¨!¦‘H�B˜Ü! $¬Ô4ØŸ	™	 $�àŸ	™	 !§&¡&¨¡*Õ-ð	 !-ô �r“7˜Q’;Ü˜b˜×*Ñ*Ó,�BÜ˜b ! R¨Ó-�AØœS "˜X™�Bà”Q—U‘U‰{ðÝ>Ù# A›J�Eð œAŸE™E‘> U¨a¢ZØÜ˜U A r¨3Ó/Ð/Ø€Iøô 'ò Ùðús   É=J3 Ê3	J?Ê>J?c                   ó4   — e Zd ZdZdd„Zed„ «       Zd„ Zd„ Zy)r   a  Represents an unevaluated limit.

    Examples
    ========

    >>> from sympy import Limit, sin
    >>> from sympy.abc import x
    >>> Limit(sin(x)/x, x, 0)
    Limit(sin(x)/x, x, 0, dir='+')
    >>> Limit(1/x, x, 0, dir="-")
    Limit(1/x, x, 0, dir='-')

    c                 ó`  — t        |«      }t        |«      }t        |«      }|t        j                  t        j                  t        j                  z  fv rd}n5|t        j                  t        j                  t        j                  z  fv rd}|j                  |«      rt        d|›d|›d�«      ‚t        |t        «      rt        |«      }n't        |t        «      st        dt        |«      z  «      ‚t        |«      dvrt        d|z  «      ‚t        j                  | «      }||||f|_        |S )	NÚ-r)   z7Limits approaching a variable point are not supported (z -> Ú)z6direction must be of type basestring or Symbol, not %s)r)   rS   ú+-z1direction must be one of '+', '-' or '+-', not %s)r   r   r2   ÚImaginaryUnitÚNegativeInfinityr;   ÚNotImplementedErrorr-   Ústrr   Ú	TypeErrorÚtypeÚ
ValueErrorr   Ú__new__Ú_args)Úclsr!   r"   r#   r$   Úobjs         r%   r]   zLimit.__new__“   s  € Ü�A‹JˆÜ�A‹JˆÜ�R‹[ˆà”!—*‘*œaŸo™o¬a¯j©jÑ8Ð9Ñ9Ø‰CØ”A×&Ñ&¬¯©¼×8JÑ8JÑ(JÐKÑKØˆCà�6‰6�!Œ9Ý%Ú34²bð':ó ;ð ;ä�cœ3ÔÜ˜“+‰CÜ˜C¤Ô(Üð %Ü'+¨C£yñ1ó 2ð 2äˆs‹8Ð+Ñ+Üð &Ø(+ñ,ó -ð -ô �l‰l˜3ÓˆØ˜˜2˜s�OˆŒ	Øˆ
r'   c                 óÜ   — | j                   d   }|j                  }|j                  | j                   d   j                  «       |j                  | j                   d   j                  «       |S )Nr   r   é   )r:   Úfree_symbolsÚdifference_updateÚupdate)Úselfr!   Úisymss      r%   rc   zLimit.free_symbols®   sS   € à�I‰I�a‰LˆØ—‘ˆØ×Ñ §	¡	¨!¡× 9Ñ 9Ô:Ø�‰�T—Y‘Y˜q‘\×.Ñ.Ô/Øˆr'   c                 ó  — | j                   \  }}}}|j                  |j                  }}|j                  |«      s$t	        |t        |«      z  ||«      }t        |«      S t	        |||«      }t	        |||«      }	|	t        j                  u r@|t        j                  t        j                  fv rt	        ||dz
  z  ||«      }t        |«      S |	t        j                  u r#|t        j                  u rt        j                  S y y )Nr   )r:   Úbaser   r;   r&   r   r   ÚOner2   rW   ÚComplexInfinity)
rf   r!   Ú_r"   r#   Úb1Úe1ÚresÚex_limÚbase_lims
             r%   Úpow_heuristicszLimit.pow_heuristics·   sÚ   € Ø—i‘i‰ˆˆ1ˆb�!Ø—‘˜Ÿ™ˆBˆØ�v‰v�aŒyÜ˜œ3˜r›7™
 A rÓ*ˆCÜ�s“8ˆOä�r˜1˜bÓ!ˆÜ˜˜Q Ó#ˆà”q—u‘uÑØœ!Ÿ*™*¤a×&8Ñ&8Ð9Ñ9Ü˜B  Q¡™K¨¨BÓ/�Ü˜3“x�Ø”q×)Ñ)Ñ)¨f¼¿
¹
Ñ.BÜ×$Ñ$Ð$ð /CÐ)r'   c           	      óv  ‡‡‡‡— | j                   \  }ŠŠŠt        ‰«      dk(  rŸt        |‰‰d¬«      }t        |‰‰d¬«      }t        |t        «      r1t        |t        «      r!|j                   d   |j                   d   k(  r| S ||k(  r|S |j
                  r|j
                  rt        j                  S t        d|›d|›�«      ‚‰t        j                  u rt        d«      ‚‰j
                  r@t        ‰«      }|t        |«      z  }|j                  ‰|‰z  «      }dŠt        j                  Š|j                  d	d
«      r6 |j                  di |¤Ž} ‰j                  di |¤ŽŠ ‰j                  di |¤ŽŠ|‰k(  r‰S |j!                  ‰«      s|S ‰t        j"                  u rt        j"                  S  |j                   t$        Ž r| S |j&                  r.t)        t        |j*                  ‰‰«      g|j                   dd ¢­Ž S t        j,                  }t        ‰«      dk(  rt        j.                  }nt        ‰«      dk(  rt        j0                  }ˆˆˆˆfd„Š|j!                  t2        «      rddlm}  ||«      } ‰|«      }|j9                  ‰‰«      rÓ‰t        j                  u r|j                  ‰d‰z  «      }| }n|j                  ‰‰‰z   «      }	 |j;                  ‰|¬«      \  }}	|	dkD  rt        j,                  S |	dk(  r|S |dk(  st=        |	«      dz  st        j                  t        |«      z  S |dk(  rt        j>                  t        |«      z  S t        j                  S ‰t        j                  u r_|j@                  rtC        |«      }tE        d‰jF                  ‰jH                  ‰jJ                  ¬«      }
|j                  ‰d|
z  «      }| }|
}n|j                  ‰‰‰z   «      }‰}	 |j;                  ||¬«      \  }}	t        |tL        «      r|	t        j,                  k(  r|S |j!                  t        j                  t        j>                  t        j                  t        j"                  «      r| S |j!                  |«      s´|	jF                  rt        j,                  S |	dk(  r|S |	jH                  rw|dk(  rt        j                  t        |«      z  S |dk(  rAt        j>                  t        |«      z  t        j0                  t        j.                  |	z   z  z  S t        j                  S t        d|	z  «      ‚‰jb                  r|je                  tf        th        «      }d}	 t_        |‰‰‰«      }|t        j"                  u s|t        j"                  u r
tO        «       ‚	 |S # t        $ r Y �ŒKw xY w# t        t        tN        f$ rÄ ddl(m)}  ||«      }|jT                  r| jW                  |«      }|�|cY S 	 |jY                  ||¬«      }||k7  r[|j!                  tZ        «      s|j!                  t        j\                  «      r't_        ||dta        |«      jH                  rdnd«      cY S n# t        t        tN        f$ r Y nw xY wY �ŒOw xY w# tN        t        f$ r |�‚ tk        |‰‰‰«      }|€| cY S Y |S w xY w)aP  Evaluates the limit.

        Parameters
        ==========

        deep : bool, optional (default: True)
            Invoke the ``doit`` method of the expressions involved before
            taking the limit.

        hints : optional keyword arguments
            To be passed to ``doit`` methods; only used if deep is True.
        rU   r)   )r$   rS   r   z1The limit does not exist since left hand limit = z and right hand limit = z.Limits at complex infinity are not implementedr   Tr   Nc                 óÀ  •— | j                   s| S t        ˆfd„| j                   D «       «      }|| j                   k7  r | j                  |Ž } t        | t        «      }t        | t
        «      }t        | t        «      }|s|s|rË	 t        | j                   d   ‰‰	‰«      }|j                  rt        d| j                   d   z  ‰‰	‰«      }|j                  rw|dk  dk(  r4|r| j                   d    S |rt        j                  S t        j                  S |dkD  dk(  r3|r| j                   d   S |rt        j                  S t        j                  S | S | S # t        $ r | cY S w xY w)Nc              3   ó.   •K  — | ]  } ‰|«      –— Œ y ­wr,   © )r.   r   Ú	set_signss     €r%   r0   z0Limit.doit.<locals>.set_signs.<locals>.<genexpr>  s   øè ø€ Ð@±i¨s™I cŸN±iùs   ƒr   r   T)r:   Útupler@   r-   r   r   r   r&   Úis_zeroÚis_extended_realr   ÚNegativeOneÚPirj   r4   rX   )
ÚexprÚnewargsÚabs_flagÚarg_flagÚ	sign_flagÚsigr$   rw   r"   r#   s
         €€€€r%   rw   zLimit.doit.<locals>.set_signs  sM  ø€ Ø—9’9Ø�ÜÓ@°d·i²iÓ@Ó@ˆGØ˜$Ÿ)™)Ò#Ø �t—y‘y 'Ð*�Ü! $¬Ó,ˆHÜ! $¬Ó,ˆHÜ" 4¬Ó.ˆIÙ™9©ðDÜ §	¡	¨!¡¨a°°SÓ9�CØ—{’{Ü# A d§i¡i°¡l¡N°A°r¸3Ó?˜ð ×+Ò+Ø !™G¨Ò,Ù5= T§Y¡Y¨q¡\ Mð JÙ5>¤A§M¡MðJÜDEÇDÁDðJà! A™g¨$Ò.Ù4< D§I¡I¨a¡Lð DÙ-6¤A§E¡EðDÜ<=¿F¹FðDàˆK�4ˆKøô +ò  Ø’Kð ús   ÂAE ÅEÅE)Ú	nsimplify)Úcdiréÿÿÿÿr"   )ÚpositiveÚnegativeÚrealzNot sure of sign of %s)Úpowsimprv   )6r:   rY   r&   r-   r   Úis_infiniter   rk   r\   rX   r   Úabsr3   r2   Úgetr    r;   r>   r   Úis_Orderr   r}   r4   rj   r{   r   r9   rƒ   Úis_meromorphicÚleadtermÚintrW   r5   r   r   Úis_positiveÚis_negativeÚis_realr   r	   Úsympy.simplify.powsimpr‰   r7   rr   Úas_leading_termr   ÚExp1r   r   Úis_extended_nonnegativeÚrewriter   r   r=   )rf   Úhintsr!   rG   rI   r„   rƒ   ÚneweÚcoeffÚexÚdummyÚnewzr‰   r$   rw   r"   r#   s                @@@@r%   r    z
Limit.doitÉ   sÑ  û€ ð Ÿ	™	‰ˆˆ1ˆb�#äˆs‹8�tÒÜ�a˜˜B CÔ(ˆAÜ�a˜˜B CÔ(ˆAÜ˜!œUÔ#¬
°1´eÔ(<Ø—6‘6˜!‘9 §¡ q¡	Ò)Ø�KØ�AŠvØ�Ø�}Š} §¢Ü×(Ñ(Ð(Ýâ !¡1ð&ó 'ð 'ð ”×"Ñ"Ñ"Ü%ð 'Có Dð Dð �>Š>Ü˜“8ˆDØœ˜D›	‘>ˆDØ—‘�q˜$˜q™&Ó!ˆAØˆCÜ—‘ˆBà�9‰9�V˜TÔ"Ø�—‘‘˜‘ˆAØ�—‘‘˜‘ˆAØ�—‘Ñ!˜5Ñ!ˆBà�Š6ØˆIà�u‰u�QŒxØˆHà”—‘‰;Ü—5‘5ˆLàˆ1�5‰5”(ÑØˆKà�:Š:Üœ˜qŸv™v q¨"Ó-Ð;°·±°q°r°
Ò;Ð;ä�v‰vˆÜˆs‹8�sŠ?Ü—5‘5‰DÜ�‹X˜Š_Ü—=‘=ˆD÷	ð4 �5‰5”Œ<õ
 :Ù˜!“ˆAÙ�a‹Lˆð ×Ñ˜A˜rÔ"Ø”Q—Z‘ZÑØ—v‘v˜a  1¡“~�à�u‘à—v‘v˜a  R¡Ó(�ð-Ø ŸM™M¨!°$˜MÓ7‘	��rð ˜’6ÜŸ6™6�MØ˜1’WØ �LØ˜1’9¤C¨£G¨a¢KÜŸ:™:¤d¨5£kÑ1Ð1Ø˜R’ZÜ×-Ñ-¬d°5«kÑ9Ð9ä×,Ñ,Ð,à”—‘ÑØ�xŠxÜ  “O�Ü˜#¨¯©ÀÇÁÐTU×T]ÑT]Ô^ˆEØ—6‘6˜!˜Q˜u™WÓ%ˆDà�5ˆDØ‰Dà—6‘6˜!˜Q ™VÓ$ˆDØˆDð"	MØŸ™ d°˜Ó6‰IˆE�2ô  ˜%¤Ô-°"¼¿¹²,Ø�Ø�y‰yœŸ™¤Q×%7Ñ%7¼×9JÑ9JÌAÏEÉEÔRØ�Ø—9‘9˜T”?Ø—>’>ÜŸ6™6�MØ˜1’WØ �LØ—^’^Ø˜q’yÜ Ÿz™z¬$¨u«+Ñ5Ð5Ø šÜ ×1Ñ1´$°u³+Ñ=¼a¿m¹mÌaÏeÉeÐVXÉjÑ>YÑYÐYä ×0Ñ0Ð0ä-Ð.FÈÑ.KÓLÐLð ×%Ò%Ø—	‘	œ)¤UÓ+ˆAàˆð		Ü�q˜!˜R Ó%ˆAØ”A—E‘E‰z˜Q¤!§%¡%™ZÜ“kÐ!ð (ð ˆøôc ò Úðûô6 Ô/´Ð;ò 	å6Ù˜“
ˆAØ�xŠxØ×'Ñ'¨Ó*�Ø�=Ø’HðØ×,Ñ,¨T¸Ð,Ó=�Ø˜D’= e§i¡i´¤n¸¿	¹	Ä!Ç&Á&Ô8IÜ! %¨¨q¼¸D»×9MÒ9M±#ÐSVÓWÒWùÜÔ 3´YÐ?ò Ùðýð	ûô^ œ:Ð&ò 	Øˆ}ØÜ˜1˜a  SÓ)ˆAØˆyØ’ð ð ˆð	úsb   ËV# Ï-V3 Õ$<Z Ö#	V0Ö/V0Ö3AZ×9A0Y-Ù)ZÙ,ZÙ-ZÚZÚZÚZÚ
ZÚ$Z8Ú7Z8N©r)   )	Ú__name__Ú
__module__Ú__qualname__Ú__doc__r]   Úpropertyrc   rr   r    rv   r'   r%   r   r   „   s+   „ ñóð6 ñó ðò%ó$Ar'   r   NrŸ   )(Ú!sympy.calculus.accumulationboundsr   Ú
sympy.corer   r   r   r   r   r	   r
   Úsympy.core.exprtoolsr   Úsympy.core.numbersr   r   Úsympy.core.functionr   Úsympy.core.symbolr   Ú(sympy.functions.combinatorial.factorialsr   Ú$sympy.functions.elementary.complexesr   r   r   r   Ú&sympy.functions.elementary.exponentialr   r   Ú'sympy.functions.special.gamma_functionsr   Úsympy.polysr   r   Úsympy.series.orderr   r   r&   r=   r   rv   r'   r%   Ú<module>r±      sO   ðÝ 9ß D× DÑ DÝ -ß .Ý ,Ý #Ý >ß EÓ Eß =Ý 9ß /Ý $Ý ó31òl<ô~FˆDõ Fr'   