o
    2ôjû3  ã                   @   sò   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d„Z%dd„ Z&G dd„ deƒZ'dS )é    )Ú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é   )Úgruntzú+c                 C   s   t | |||ƒjd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Údir© r$   úd/var/www/html/academy/tools/voices/clone/sv-venv/lib/python3.10/site-packages/sympy/series/limits.pyÚlimit   s   3r&   c                 C   s6  d}|t ju rt|  |d| ¡|t jdƒ}t|tƒrdS |S | js1| js1| j	s1| j
�rt| tƒ�sg }ddlm} | jD ]X}t||||ƒ}| t j¡r|jdu rt| tƒr|t| ƒ}	t|	tƒsb||	ƒ}	t|	tƒskt| ƒ}	t|	tƒryt|	|||ƒ  S  dS  dS t|tƒr‡ dS |t ju r� dS | |¡ q<|�r| j|Ž }|t ju rç| jrçtdd„ |D ƒƒrçg }
g }t|ƒD ]\}}t|tƒrÅ|
 |¡ q¶| | j| ¡ q¶t|ƒdkrçt|Ž  ¡ }t||||ƒ}|t|
Ž  }|t ju �rzddlm} || ƒ}W n t �y   Y dS w |t ju �s|| k�rdS t||||ƒS |S )	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   r   )Útogetherc                 s   s   � | ]}t |tƒV  qd S ©N)Ú
isinstancer   )Ú.0Úrrr$   r$   r%   Ú	<genexpr>j   s   € zheuristics.<locals>.<genexpr>)Ú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.ratsimpr-   r   )r    r!   r"   r#   ÚrvÚrr'   ÚaÚlÚmÚr2Úe2ÚiiÚrvalZe3r-   Zrat_er$   r$   r%   r9   E   sf   

0&Ñ







"
ÿr9   c                   @   s6   e Zd ZdZddd„Zedd„ ƒZdd„ Zd	d
„ ZdS )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='-')

    r   c                 C   sÊ   t |ƒ}t |ƒ}t |ƒ}|tjtjtj fv rd}n|tjtjtj fv r'd}| |¡r4td||f ƒ‚t|tƒr>t	|ƒ}nt|t	ƒsKt
dt|ƒ ƒ‚t|ƒdvrWtd| ƒ‚t | ¡}||||f|_|S )Nú-r   z@Limits approaching a variable point are not supported (%s -> %s)z6direction must be of type basestring or Symbol, not %s)r   rK   ú+-z1direction must be one of '+', '-' or '+-', not %s)r   r   r.   ÚImaginaryUnitÚNegativeInfinityr7   ÚNotImplementedErrorr)   Ústrr   Ú	TypeErrorÚtypeÚ
ValueErrorr   Ú__new__Ú_args)Úclsr    r!   r"   r#   Úobjr$   r$   r%   rT   “   s0   
ÿ


ÿÿ
zLimit.__new__c                 C   s8   | j d }|j}| | j d j¡ | | j d j¡ |S )Nr   r   é   )r6   Úfree_symbolsÚdifference_updateÚupdate)Úselfr    Zisymsr$   r$   r%   rY   ®   s
   
zLimit.free_symbolsc           
      C   s²   | j \}}}}|j|j}}| |¡s!t|t|ƒ ||ƒ}t|ƒS t|||ƒ}t|||ƒ}	|	tju rH|tjtj	fv rHt||d  ||ƒ}t|ƒS |	tj	u rU|tju rWtj
S d S d S )Nr   )r6   Úbaser   r7   r&   r   r   ÚOner.   rN   ÚComplexInfinity)
r\   r    Ú_r!   r"   Úb1Úe1ÚresZex_limZbase_limr$   r$   r%   Úpow_heuristics·   s   

ÿzLimit.pow_heuristicsc                    s<  | j \}‰‰‰ tˆ ƒdkrJt|ˆˆdd�}t|ˆˆdd�}t|tƒr3t|tƒr3|j d |j d kr3| S ||kr9|S |jrB|jrBtjS td||f ƒ‚ˆtju rSt	dƒ‚ˆjrmt
ˆƒ}|t|ƒ }| ˆ|ˆ ¡}d‰ tj‰| dd	¡r‹|jdi |¤Ž}ˆjdi |¤Ž‰ˆjdi |¤Ž‰|ˆkr‘ˆS | ˆ¡s˜|S ˆtju r tjS |jtŽ r§| S |jr¼tt|jˆˆƒg|j d
d… ¢R Ž S tj}tˆ ƒdkrÉtj}n	tˆ ƒdkrÒtj}‡ ‡‡‡fdd„‰| t¡rêddlm} ||ƒ}ˆ|ƒ}| ˆˆ¡�rVˆtju �r| ˆd
ˆ ¡}| }n| ˆˆˆ ¡}z|jˆ|d�\}}	W n
 t�y$   Y n2w |	dk�r-tjS |	dk�r4|S |d
k�s@t|	ƒd
@ �sGtjt
|ƒ S |dk�rStjt
|ƒ S tjS ˆtju �r}|j �rdt!|ƒ}t"dˆj#ˆj$ˆj%d�}
| ˆd
|
 ¡}| }|
}n
| ˆˆˆ ¡}ˆ}z|j||d�\}}	W nd tt	t&f�yö   ddl'm(} ||ƒ}|j)�r¹|  *|¡}|du�r¹| Y S z-|j+||d�}||k�rå| t,¡�sÓ| tj-¡�råt.||dt/|ƒj$�rßdndƒW  Y S W n tt	t&f�yó   Y nw Y n_w t|t0ƒ�r|	tjk�r|S | tjtjtjtj¡�r| S | |¡�sU|	j#�r!tjS |	dk�r(|S |	j$�rO|d
k�r8tjt
|ƒ S |dk�rLtjt
|ƒ tjtj|	   S tjS t	d|	 ƒ‚ˆj1�r_| 2t3t4¡}d}zt.|ˆˆˆ ƒ}|tju �su|tju �rxt&ƒ ‚W |S  t&tf�y�   |du�rŠ‚ t5|ˆˆˆ ƒ}|du �rš|  Y S Y |S 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.
        rL   r   )r#   rK   r   zMThe limit does not exist since left hand limit = %s and right hand limit = %sz.Limits at complex infinity are not implementedr   Tr   Nc                    s  | j s| S t‡fdd„| j D ƒƒ}|| j kr| j|Ž } t| tƒ}t| tƒ}t| tƒ}|s0|s0|r…zt| j d ˆˆˆ ƒ}|jrJtd| j d  ˆˆˆ ƒ}W n t	yV   |  Y S w |j
r…|dk dkrp|rh| j d  S |rmtjS tjS |dkdkr…|r}| j d S |r‚tjS tjS | S )Nc                 3   s   � | ]}ˆ |ƒV  qd S r(   r$   )r*   r   )Ú	set_signsr$   r%   r,     s   € z0Limit.doit.<locals>.set_signs.<locals>.<genexpr>r   r   T)r6   Útupler<   r)   r   r   r   r&   Úis_zerorO   Úis_extended_realr   ÚNegativeOneÚPir^   r0   )ÚexprÚnewargsZabs_flagZarg_flagZ	sign_flagÚsig©r#   re   r!   r"   r$   r%   re     s>   




€ÿÿÿÿÿzLimit.doit.<locals>.set_signs)Ú	nsimplify)Úcdiréÿÿÿÿr!   )ÚpositiveÚnegativeÚreal)ÚpowsimpzNot sure of sign of %sr$   )6r6   rP   r&   r)   r   Úis_infiniter   r_   rS   rO   r   Úabsr/   r.   Úgetr   r7   r:   r   Úis_Orderr   rk   r0   r^   ri   r   r5   ro   Úis_meromorphicÚleadtermÚintrN   r1   r
   r   Úis_positiveÚis_negativeÚis_realr   Úsympy.simplify.powsimpru   r3   rd   Úas_leading_termr   ÚExp1r   r   r   Úis_extended_nonnegativeÚrewriter   r   r9   )r\   Úhintsr    rC   rE   rp   ro   ÚneweÚcoeffÚexÚdummyÚnewzru   r$   rn   r%   r   É   sþ   þ



$
ÿ




$$€ÿ€ô


ÿ	ù

ÿùz
Limit.doitN©r   )	Ú__name__Ú
__module__Ú__qualname__Ú__doc__rT   ÚpropertyrY   rd   r   r$   r$   r$   r%   r   „   s    

r   Nr‹   )(Ú!sympy.calculus.accumulationboundsr   Ú
sympy.corer   r   r   r   r   r   r	   Z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&   r9   r   r$   r$   r$   r%   Ú<module>   s     $
6?