U
    ZÊ¹j+2  ã                   @   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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)Ú	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"   úR/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/series/limits.pyÚlimit   s    3r$   c                 C   s<  d}|t jkr<t|  |d| ¡|t jdƒ}t|tƒr8dS �nü| jsV| jsV| j	sV| j
�r8g }ddlm} | jD ]´}t||||ƒ}| t j¡rò|jdkròt| tƒrìt| ƒ}	t|	tƒs¸||	ƒ}	t|	tƒsÊt| ƒ}	t|	tƒræt|	|||ƒ  S  dS  dS t|tƒ�r dS |t jk�r dS | |¡ ql|�r8| j|Ž }|t jk�rÒ| j�rÒtdd„ |D ƒƒ�rÒg }
g }t|ƒD ]2\}}t|tƒ�rŠ|
 |¡ n| | j| ¡ �qjt|ƒdk�rÒt|Ž  ¡ }t||||ƒ}|t|
Ž  }|t jk�r8zddlm} || ƒ}W n tk
�r   Y dS X |t jk�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   )Ú.0Zrrr"   r"   r#   Ú	<genexpr>h   s     zheuristics.<locals>.<genexpr>)Úratsimp) r   ÚInfinityr$   ÚsubsÚZeror'   r   Úis_MulZis_AddÚis_PowZis_FunctionÚsympy.simplify.simplifyr%   ÚargsÚhasÚ	is_finiter   r
   r	   r   Ú
heuristicsÚNaNÚappendÚfuncÚanyÚ	enumerater   ÚlenÚsimplifyZsympy.simplify.ratsimpr*   r   )r   r   r    r!   ÚrvÚrr%   ÚaÚlÚmÚr2Úe2ÚiiÚrvalZe3r*   Zrat_er"   r"   r#   r4   C   sb    







(r4   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kr4d}n|tjtjtj fkrNd}| |¡rhtd||f ƒ‚t|tƒr|t	|ƒ}nt|t	ƒs–t
dt|ƒ ƒ‚t|ƒdkr®t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   rE   ú+-z1direction must be one of '+', '-' or '+-', not %s)r   r   r+   ZImaginaryUnitÚNegativeInfinityr2   ÚNotImplementedErrorr'   Ústrr   Ú	TypeErrorÚtypeÚ
ValueErrorr   Ú__new__Ú_args)Úclsr   r   r    r!   Úobjr"   r"   r#   rM   ‘   s0    
ÿ


ÿÿ
zLimit.__new__c                 C   s8   | j d }|j}| | j d j¡ | | j d j¡ |S )Nr   r   é   )r1   Úfree_symbolsÚdifference_updateÚupdate)Úselfr   Zisymsr"   r"   r#   rR   ¬   s
    
zLimit.free_symbolsc           
      C   s®   | j \}}}}|j|j }}| |¡sBt|t|ƒ ||ƒ}t|ƒS t|||ƒ}t|||ƒ}	|	tjkr�|tjtj	fkr�t||d  ||ƒ}t|ƒS |	tj	krª|tjkrªtj
S d S )Nr   )r1   Úbaser   r2   r$   r   r   ÚOner+   rG   ÚComplexInfinity)
rU   r   Ú_r   r    Úb1Úe1ÚresZex_limZbase_limr"   r"   r#   Úpow_heuristicsµ   s    

zLimit.pow_heuristicsc                    s&  | j \}‰‰‰ tˆ ƒdkr”t|ˆˆdd�}t|ˆˆdd�}t|tƒrft|tƒrf|j d |j d krf| S ||krr|S |jr„|jr„tjS td||f ƒ‚ˆtjkr¦t	dƒ‚ˆjrÚt
ˆƒ}|t|ƒ }| ˆ|ˆ ¡}d‰ tj‰| dd	¡�r|jf |Ž}ˆjf |Ž‰ˆjf |Ž‰|ˆk�rˆS | ˆ¡�s*|S ˆtjk�r<tjS |jtŽ �rL| S |j�rvtt|jˆˆƒf|j d
d… žŽ S d}tˆ ƒdk�rŽd
}ntˆ ƒdk�r d}‡ ‡‡‡fdd„‰| t¡�rÒddlm} ||ƒ}ˆ|ƒ}| ˆˆ¡�r¬ˆtjk�r| ˆd
ˆ ¡}| }n| ˆˆˆ ¡}z|jˆ|d�\}}	W n tk
�rH   Y ndX |	dk�rZtjS |	dk�rh|S |d
k�s€t|	ƒd
@ �sŽtjt
|ƒ S |dk�r¦tjt
|ƒ S tjS ˆtjk�rà|j�rÈt|ƒ}| ˆd
ˆ ¡}| }n| ˆˆˆ ¡}z|jˆ|d�\}}	W nÌ tt	t fk
�rÒ   ddl!m"}
 |
|ƒ}|j#�rV|  $|¡}|dk	�rV| Y S zZ|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k
�rÌ   Y nX Y nÀX t|t+ƒ�rð|	tjk�rð|S | tjtjtjtj¡�r| S | ˆ¡�s’|	j,�r(tjS |	dk�r6|S |	j*�r†|d
k�rVtjt
|ƒ S |dk�r~tjt
|ƒ tj-tj.|	   S tjS nt	d|	 ƒ‚ˆj/�r¦| 0t1t2¡}d}z0t(|ˆˆˆ ƒ}|tjk�sÒ|tjk�rØt ƒ ‚W nF t tfk
�r    |dk	�rü‚ t3|ˆˆˆ ƒ}|dk�r|  Y S Y nX |S )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.
        rF   r   )r!   rE   r   zMThe limit does not exist since left hand limit = %s and right hand limit = %sz.Limits at complex infinity are not implementedr   Tr   Néÿÿÿÿc                    sò   | j s
| S t‡fdd„| j D ƒƒ}|| j kr6| j|Ž } t| tƒ}t| tƒ}t| tƒ}|s`|s`|rît| j d ˆˆˆ ƒ}|jr’td| j d  ˆˆˆ ƒ}|j	rî|dk dkrÄ|r´| j d  S |r¾t
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)r1   Útupler7   r'   r   r   r   r$   Úis_zeroZis_extended_realr   ÚNegativeOneÚPirW   r-   )ÚexprZnewargsZabs_flagZarg_flagZ	sign_flagÚsig©r!   r_   r   r    r"   r#   r_   
  s,    




ÿÿzLimit.doit.<locals>.set_signs)Ú	nsimplify)Úcdir)ÚpowsimpzNot sure of sign of %s)4r1   rI   r$   r'   r   Úis_infiniter   rX   rL   rH   r   Úabsr,   r+   Úgetr   r2   r5   r   Zis_Orderr   rd   r   r0   rg   Zis_meromorphicZleadtermr-   ÚintrG   r.   r
   r   Zsympy.simplify.powsimpri   r/   r]   Zas_leading_termr   ZExp1r   r   Zis_negativer   Zis_positiverb   rW   Zis_extended_positiveZrewriter   r   r4   )rU   Úhintsr   r=   r?   rh   rg   ZneweZcoeffÚexri   r"   rf   r#   r   Ç   sæ    þ

"




$(





z
Limit.doitN)r   )	Ú__name__Ú
__module__Ú__qualname__Ú__doc__rM   ÚpropertyrR   r]   r   r"   r"   r"   r#   r   ‚   s   

r   N)r   )$Z!sympy.calculus.accumulationboundsr   Z
sympy.corer   r   r   r   r   r   r	   Zsympy.core.exprtoolsr
   Zsympy.core.numbersr   r   Z(sympy.functions.combinatorial.factorialsr   Z$sympy.functions.elementary.complexesr   r   r   r   Z&sympy.functions.elementary.exponentialr   r   Z'sympy.functions.special.gamma_functionsr   Zsympy.polysr   r   Zsympy.series.orderr   r   r$   r4   r   r"   r"   r"   r#   Ú<module>   s   $
6?