a
    RG5d0                     @   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 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)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!   O/var/www/html/django/DPS/env/lib/python3.9/site-packages/sympy/series/limits.pylimit   s    3r#   c                 C   sR  d}t |tju rNt| |d| |tj|tju r6dnd}t|trJdS n | jsh| j	sh| j
sh| jrNg }ddlm} | jD ]}t||||}|tjr
|jdu r
t| trt| }	t|	ts||	}	t|	tst| }	t|	trt|	|||  S  dS  dS t|tr dS |tju r. dS || q~|rN| j| }|tju r| jrtdd |D rg }
g }t|D ]2\}}t|tr|
| n|| j|  qt|dkrt|  }t||||}|t|
  }|tju rNzdd	lm} || }W n t y$   Y dS 0 |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>h       zheuristics.<locals>.<genexpr>)ratsimp)!absr   Infinityr#   subsZeror'   r   is_Mulis_Addis_Powis_Function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   C   sb    *





(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   zRepresents 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)
    >>> 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 r4d}n|tjtjtj fv rNd}||rhtd||f t|tr|t	|}nt|t	st
dt| t|dvrtd| t| }||||f|_|S )Nr$   r   z@Limits approaching a variable point are not supported (%s -> %s)z6direction must be of type basestring or Symbol, not %s)r   r$   +-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"   rS      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"   rX      s
    
zLimit.free_symbolsc           
      C   s   | j \}}}}|j|j }}||sBt|t| ||}t|S t|||}t|||}	|	tju r|tjtj	fv rt||d  ||}t|S |	tj	u r|tju rtj
S d S )Nr   )r6   baser   r7   r#   r   r   Oner.   rM   ComplexInfinity)
r[   r   _r   r   b1e1resZex_limZbase_limr!   r!   r"   pow_heuristics   s    

zLimit.pow_heuristicsc              
      sp  | j \} tju r td|ddr\|jf i |}jf i |jf i ||krhS |sv|S tju rtjS |jt r| S |j	rt
t|jg|j dd R  S d}t dkrd}nt dkrd	} fd
d|trddlm} ||}|}|rttju rT|d }| }n| }z|j|d\}}W n ty   Y nd0 |dkrtjS |dkr|S |dkst|d@ stjt| S |d	krtjt| S tjS ttju r*|jrt|}|d }| }n| }z|j|d\}}W nT tttfy   ddlm} ||}|j r| !|}	|	dur|	 Y S Y  n0 t"|t#r|tjkr|S |tjtjtjtjr| S |s|j$rtjS |dkr|S |j%r|j&rX|dks*|j'r8tjt| S |d	krPtjt| S tjS n@|dkrptjt| S |d	krtjt| tj(|  S tjS j)r|*t+t,}d}
zvt dkrt-|d}	t-|d}
|
|	krtd|
|	f nt-| }	|	tju s|
tju r$t W nD ttfyj   |
durF t.| }	|	du rf|  Y S Y n0 |	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.
        z.Limits at complex infinity are not implementedr   Tr   Nr   r   r$   c                    s   | j s
| S tfdd| j D }|| j kr6| j| } t| t}t| t}t| t}|s`|s`|rt| j d  }|jrtd| j d   }|j	r|dk dkr|r| j d  S |rt
jS t
jS |dkdkr|r| j d S |rt
jS t
jS | S )Nc                 3   s   | ]} |V  qd S r&   r!   )r(   r   )	set_signsr!   r"   r*      r+   z0Limit.doit.<locals>.set_signs.<locals>.<genexpr>r   r   T)r6   tupler<   r'   r   r   r   r#   is_zero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)powsimprK   zMThe limit does not exist since left hand limit = %s and right hand limit = %s)/r6   r   r^   rN   getr   r7   r:   r   is_Orderr   r#   rk   rO   r   r5   ro   is_meromorphicr-   r.   r/   leadtermrR   r0   intr   rM   r1   r
   r   sympy.simplify.powsimprq   r3   rc   r'   r   is_positiveis_negative
is_integeris_evenri   is_extended_positiverewriter   r   r   r9   )r[   hintsr   rp   ro   newecoeffexrq   rC   rE   r!   rn   r"   r      s    



$












z
Limit.doitN)r   )	__name__
__module____qualname____doc__rS   propertyrX   rc   r   r!   r!   r!   r"   r      s   

r   N)r   )#!sympy.calculus.accumulationboundsr   
sympy.corer   r   r   r   r   r   r	   Zsympy.core.exprtoolsr
   sympy.core.numbersr   r   (sympy.functions.combinatorial.factorialsr   $sympy.functions.elementary.complexesr   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?