o
    e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"   CD:\Projects\ConvertPro\env\Lib\site-packages\sympy/series/limits.pylimit   s   3r$   c                 C   s(  d}|t ju rt| |d| |t jd}t|trdS |S | js+| js+| j	s+| j
rg }ddlm} | jD ]X}t||||}|t jry|jdu ryt| trvt| }	t|	ts\||	}	t|	tset| }	t|	trst|	|||  S  dS  dS t|tr dS |t ju r dS || q6|r| j| }|t ju r| jrtdd |D rg }
g }t|D ]\}}t|tr|
| q|| j|  qt|dkrt|  }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>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#   r5   C   sf   

0







"
r5   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   rF   +-z1direction must be one of '+', '-' or '+-', not %s)r   r   r,   ZImaginaryUnitNegativeInfinityr3   NotImplementedErrorr'   strr   	TypeErrortype
ValueErrorr   __new___args)clsr   r   r    r!   objr"   r"   r#   rN      s0   




zLimit.__new__c                 C   s8   | j d }|j}|| j d j || j d j |S )Nr   r      )r2   free_symbolsdifference_updateupdate)selfr   Zisymsr"   r"   r#   rS      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   )r2   baser   r3   r$   r   r   Oner,   rH   ComplexInfinity)
rV   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 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rddlm} ||}|}|rStju r|d
 }| }n| }z|j|d\}}	W n
 ty!   Y n2w |	dkr*tjS |	dkr1|S |d
ks=t|	d
@ sDtjt
| S |dkrPtjt
| S tjS tju rm|jrat|}|d
 }| }n| }z|j|d\}}	W n] tt	t fy   ddl!m"}
 |
|}|j#r| $|}|dur| Y S z&|j%|d}||kr|t&rt'|dt(|j)rdndW  Y S W n tt	t fy   Y nw Y n_w 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r|S |	j)r6|d
krtjt
| S |dkr3tjt
| tj,tj-|	   S tjS t	d|	 j.rF|/t0t1}d}zt'| }|tju s\|tju r_t  W |S  t tfy   |durq t2| }|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.
        rG   r   )r!   rF   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|rwt| j d  }|jrItd| j d   }|j	rw|dk dkrb|rZ| j d  S |r_t
jS t
jS |dkdkrw|ro| j d S |rtt
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)r2   tupler8   r'   r   r   r   r$   is_zeroZis_extended_realr   NegativeOnePirX   r.   )exprZnewargsZabs_flagZarg_flagZ	sign_flagsigr!   r`   r   r    r"   r#   r`   
  s4   




zLimit.doit.<locals>.set_signs)	nsimplify)cdir)powsimpzNot sure of sign of %sr"   )3r2   rJ   r$   r'   r   is_infiniter   rY   rM   rI   r   absr-   r,   getr   r3   r6   r   Zis_Orderr   re   r   r1   rh   Zis_meromorphicZleadtermr.   intrH   r/   r
   r   Zsympy.simplify.powsimprj   r0   r^   Zas_leading_termr   r   r   Zis_negativer   Zis_positiverc   rX   Zis_extended_positiveZrewriter   r   r5   )rV   hintsr   r>   r@   ri   rh   ZneweZcoeffexrj   r"   rg   r#   r      s   



$





$


	

z
Limit.doitNr   )	__name__
__module____qualname____doc__rN   propertyrS   r^   r   r"   r"   r"   r#   r      s    

r   Nrq   )$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$   r5   r   r"   r"   r"   r#   <module>   s    $
6?