403Webshell
Server IP : 93.86.61.54  /  Your IP : 216.73.216.156
Web Server : Apache/2.4.62 (Ubuntu)
System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64
User : www-data ( 33)
PHP Version : 8.4.22
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /usr/lib/python3/dist-packages/sympy/integrals/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /usr/lib/python3/dist-packages/sympy/integrals/__pycache__/integrals.cpython-310.pyc
o

�8Va��@s�ddlmZddlmZddlmZddlmZddlm	Z	ddl
mZddlm
Z
ddlmZdd	lmZdd
lmZmZddlmZddlmZdd
lmZmZmZddlmZddlm Z m!Z!m"Z"m#Z#m$Z$m%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+m,Z,ddl-m.Z.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5m6Z6ddl7m8Z8ddl9m:Z:m;Z;ddl<m=Z=ddl>m?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGddlHmIZIGd d!�d!e�ZJd"d#d"d"d"d$�d%d&�ZKd'd(�ZLeE�MeJ�d)d*��ZNd"S)+�)�
AddWithLimits)�Add)�Basic)�is_sequence)�Tuple)�Expr)�diff)�
fuzzy_bool)�Mul)�oo�pi)�Ne)�S)�Dummy�Symbol�Wild)�sympify)�	Piecewise�sqrt�piecewise_fold�tan�cot�atan)�log)�floor)�Abs�sign)�Min�Max)�manualintegrate)�
trigintegrate)�meijerint_definite�meijerint_indefinite)�
MatrixBase)�Poly�PolynomialError)�limit)�Order)�FormalPowerSeries)�
sincos_to_sum)�shape)�
filldedent)�SymPyDeprecationWarningc@s�eZdZdZdZdd�Zdd�Zedd��Zd	d
�Z	dd�Z
d
d�Zdd�Z		d$dd�Z
d%dd�Zd%dd�Zd%dd�Zdd�Zd&d d!�Zd"d#�ZdS)'�Integralz Represents unevaluated integral.)�is_commutativecOsVt|d�r
|j|i|��St|t�rtddddd���tj||g|�Ri|��}|S)a�Create an unevaluated integral.

        Explanation
        ===========

        Arguments are an integrand followed by one or more limits.

        If no limits are given and there is only one free symbol in the
        expression, that symbol will be used, otherwise an error will be
        raised.

        >>> from sympy import Integral
        >>> from sympy.abc import x, y
        >>> Integral(x)
        Integral(x, x)
        >>> Integral(y)
        Integral(y, y)

        When limits are provided, they are interpreted as follows (using
        ``x`` as though it were the variable of integration):

            (x,) or x - indefinite integral
            (x, a) - "evaluate at" integral is an abstract antiderivative
            (x, a, b) - definite integral

        The ``as_dummy`` method can be used to see which symbols cannot be
        targeted by subs: those with a prepended underscore cannot be
        changed with ``subs``. (Also, the integration variables themselves --
        the first element of a limit -- can never be changed by subs.)

        >>> i = Integral(x, x)
        >>> at = Integral(x, (x, x))
        >>> i.as_dummy()
        Integral(x, x)
        >>> at.as_dummy()
        Integral(_0, (_0, x))

        �_eval_Integral�"Using integrate/Integral with Poly�H�1.6�(the as_expr or integrate methods of Poly��feature�issue�deprecated_since_version�
useinstead)�hasattrr/�
isinstancer$r,�warnr�__new__)�cls�function�symbols�assumptions�obj�rB�;/usr/lib/python3/dist-packages/sympy/integrals/integrals.pyr<'s
*
�zIntegral.__new__cCs|jftdd�|jD��S)NcSsg|]}t|��qSrB)�tuple��.0�xabrBrBrC�
<listcomp>_sz+Integral.__getnewargs__.<locals>.<listcomp>)r>rD�limits��selfrBrBrC�__getnewargs__^szIntegral.__getnewargs__cCstj�|�S)ao
        This method returns the symbols that will exist when the
        integral is evaluated. This is useful if one is trying to
        determine whether an integral depends on a certain
        symbol or not.

        Examples
        ========

        >>> from sympy import Integral
        >>> from sympy.abc import x, y
        >>> Integral(x, (x, y, 1)).free_symbols
        {y}

        See Also
        ========

        sympy.concrete.expr_with_limits.ExprWithLimits.function
        sympy.concrete.expr_with_limits.ExprWithLimits.limits
        sympy.concrete.expr_with_limits.ExprWithLimits.variables
        )r�free_symbols�fgetrJrBrBrCrMaszIntegral.free_symbolscCs|jjrdSd}|jD]$}t|�dkr/|d|dkp#|d|dj}|r)dS|dur/d}q|jj}|jD]C}t|�dkrG|�|d�q7t|�dkrd|d|vrd|djr[dS|djdurdd}|�|d�|dd�D]}|�|j�qqq7|jjdur�|dur�dSdSdS)NTF���r)r>�is_zerorI�lenrM�add�discard�update)rK�got_none�l�z�freerG�irBrBrC�
_eval_is_zerozs8
"�

��zIntegral._eval_is_zerocsFddlm}m}td��|j��j�}t|�dkr td�j��|r&|�	�n����jvr/�St
|�}t|t�rX|j}t|�dkrGtt
d���t|�dkrStt
d���|�	��n|\}��|jvrgtt
d���t�t�sttt
d	����|jr�|jr���||i�S|js�|js�td
����kr���||�����f����i�S��jvr�tt
d���|js�|����g�|||�dd
�}|s�td����fdd�|D�}n7|����g}|||�\}	���dd����D��}
�fdd�||	|
�D�}|s�td����fdd�|D������fdd�|D�}t|�dk�rtt
d���|�	�}�fdd����fdd�}
g}�jD]d}|d}|�k�r�t|�dk�ru|dd�\}}|
||�|
||�}}t||dk��rk||}}|}|��||f��q5t|�dk�r�|
|dd�}|��|f��q5|����q5|�|��q5�j|g|�R�S)a�
        Performs a change of variables from `x` to `u` using the relationship
        given by `x` and `u` which will define the transformations `f` and `F`
        (which are inverses of each other) as follows:

        1) If `x` is a Symbol (which is a variable of integration) then `u`
           will be interpreted as some function, f(u), with inverse F(u).
           This, in effect, just makes the substitution of x with f(x).

        2) If `u` is a Symbol then `x` will be interpreted as some function,
           F(x), with inverse f(u). This is commonly referred to as
           u-substitution.

        Once f and F have been identified, the transformation is made as
        follows:

        .. math:: \int_a^b x \mathrm{d}x \rightarrow \int_{F(a)}^{F(b)} f(x)
                  \frac{\mathrm{d}}{\mathrm{d}x}

        where `F(x)` is the inverse of `f(x)` and the limits and integrand have
        been corrected so as to retain the same value after integration.

        Notes
        =====

        The mappings, F(x) or f(u), must lead to a unique integral. Linear
        or rational linear expression, ``2*x``, ``1/x`` and ``sqrt(x)``, will
        always work; quadratic expressions like ``x**2 - 1`` are acceptable
        as long as the resulting integrand does not depend on the sign of
        the solutions (see examples).

        The integral will be returned unchanged if ``x`` is not a variable of
        integration.

        ``x`` must be (or contain) only one of of the integration variables. If
        ``u`` has more than one free symbol then it should be sent as a tuple
        (``u``, ``uvar``) where ``uvar`` identifies which variable is replacing
        the integration variable.
        XXX can it contain another integration variable?

        Examples
        ========

        >>> from sympy.abc import a, x, u
        >>> from sympy import Integral, cos, sqrt

        >>> i = Integral(x*cos(x**2 - 1), (x, 0, 1))

        transform can change the variable of integration

        >>> i.transform(x, u)
        Integral(u*cos(u**2 - 1), (u, 0, 1))

        transform can perform u-substitution as long as a unique
        integrand is obtained:

        >>> i.transform(x**2 - 1, u)
        Integral(cos(u)/2, (u, -1, 0))

        This attempt fails because x = +/-sqrt(u + 1) and the
        sign does not cancel out of the integrand:

        >>> Integral(cos(x**2 - 1), (x, 0, 1)).transform(x**2 - 1, u)
        Traceback (most recent call last):
        ...
        ValueError:
        The mapping between F(x) and f(u) did not give a unique integrand.

        transform can do a substitution. Here, the previous
        result is transformed back into the original expression
        using "u-substitution":

        >>> ui = _
        >>> _.transform(sqrt(u + 1), x) == i
        True

        We can accomplish the same with a regular substitution:

        >>> ui.transform(u, x**2 - 1) == i
        True

        If the `x` does not contain a symbol of integration then
        the integral will be returned unchanged. Integral `i` does
        not have an integration variable `a` so no change is made:

        >>> i.transform(a, x) == i
        True

        When `u` has more than one free symbol the symbol that is
        replacing `x` must be identified by passing `u` as a tuple:

        >>> Integral(x, (x, 0, 1)).transform(x, (u + a, u))
        Integral(a + u, (u, -a, 1 - a))
        >>> Integral(x, (x, 0, 1)).transform(x, (u + a, a))
        Integral(a + u, (a, -u, 1 - u))

        See Also
        ========

        sympy.concrete.expr_with_limits.ExprWithLimits.variables : Lists the integration variables
        as_dummy : Replace integration variables with dummy ones
        r)�solve�posify�drPz F(x) can only contain one of: %sz*
                f(u) cannot be a constantz�
                When f(u) has more than one free symbol, the one replacing x
                must be identified: pass f(u) as (f(u), u)z�
                Expecting a tuple (expr, symbol) where symbol identified
                a free symbol in expr, but symbol is not in expr's free
                symbols.za
                Expecting a tuple (expr, symbol) but didn't get
                a symbol; got %szeither x or u must be a symbolz{
            u must contain the same variable as in x
            or a variable that is not already an integration variableF)�checkz%no solution for solve(F(x) - f(u), x)c�g|]}|�����qSrB��subs�rF�fi)r_�uvarrBrCrH;�z&Integral.transform.<locals>.<listcomp>cSsg|]\}}||f�qSrBrB�rF�k�vrBrBrCrH?rgc�g|]}|����qSrBrb�rF�s)�repsrBrCrH@�z%no solution for solve(F(x) - f(u), u)crarBrbrd)r_�xvarrBrCrHCrgcs,h|]}�j��|�|��������qSrB)r>rcrrd)r_rKrfrprBrC�	<setcomp>Es
��z%Integral.transform.<locals>.<setcomp>z[
            The mapping between F(x) and f(u) did not give
            a unique integrand.cs>|��|�}|tjus|jdur|jrtt|�|�|�S|S)�}
            replace d with a, using subs if possible, otherwise limit
            where sign of b is considered
            F)rcr�NaN�	is_finiter&r)�F�a�b�wok)r_rBrC�
_calc_limit_1Msz)Integral.transform.<locals>._calc_limit_1cs:t���fdd��D��}t|�dkrttd���|dS)rrcsh|]}�|����qSrBrB)rF�Fi)ryrvrwrBrCrq\rgz:Integral.transform.<locals>._calc_limit.<locals>.<setcomp>rPz_
                The mapping between F(x) and f(u) did not
                give a unique limit.r)�listrS�
ValueErrorr+)rvrw�avals)rury�rvrwrC�_calc_limitWsz'Integral.transform.<locals>._calc_limitrONrQ)�sympy.solvers.solversr]r^rrM�intersection�	variablesrSr|�poprr:rr+r�	is_Symbol�xreplace�	transformrcrI�itemsr	�append�func)rK�x�ur]r^�xfree�ufree�soln�f�pdiff�puvar�newfuncs�newfuncr�	newlimitsrG�symrvrwrB)ruryr_rnrKrfrprCr��s�g�




�"
�



zIntegral.transformc)
s�	ddlm}��dd�s�S��dd�}��dd����dd	����d
d�}��dd�}��dd�}tttd|�||f���d
krEtd��|rNd�}}n�rWd}}}n|r`d}�}n|rhd}�}t�|||�d�}�dvr{td���|r�tdd��j	D��r�td���j
r�tjSt
�j|�r�t�fdd��jD��r�td��tdd��jj	dd
d�D��r��S�}�j}	|	j|j|	jg|j	�R���g|	j	�R���S�j}
|r�|
jd6i���}
|
j
r�tjSt
|
t�r�|
���fdd��St
|
t��r(t�j	�d
k�rt��j	d}t|�d
k�r|
j|fi|��S|
j|dfi|��Si}�j	D]Z}t|�dk�r8�q-|\�
����f}
tdd�|
D���rU�
j�sUtdd�}n*tdd�|
D���ri�
j�sitdd�}ntd d�|
D���r}�
j�s}tdd!�}nd}|�r�||�
<�q-|�r�d"d#�|��D��	��|�jd6i���}t|�tu�r�t�	fd$d%�|D��}|S|��	�}|Sg}t �}�j	D�]%}t|�d
k�r�t |dd
���nt|�d&k�r�|d
j!�nt|�dk�r�|d
j!�"|d&j!��|d|v�st�fd'd�|D���r(|�#|�|�$���j|
g|g�}
|
�%�}t
|t&��s&|}
�q�|
�'t(t)��rot|�dk�r@td(d�|D���sUt|�dk�rotd)d�|d
d�D���rotd*dd!�}|
�|d|i��*t+��||di�}
n|
�'t,t-��r{|
�*t+�}
|
�'t+��r�t
|
t+��s�t.|
�}
t
|
t+��r�t|�d
k�r�|
j/|dfi|��}n��j/|
|dfi|��}n{���fd+d,�}�}�du�r�t|�dk�r�|d
j0�r�|d&j0�r�|
j1�s�|d
�'t2t2��s�|d&�'t2t2��r�||
|�}|du�r�|}
�q�d}|du�r�du�rd}n$�j/|
|dfi|��}|du�r,�du�r,||
|�}|du�r,|}
�qˆ�d-d�}|�r�t
|t&��s�|du�r�|�3t4�D]x}|j5d}|�3t6�D]4}td.�}|�7||�}|�8|�}||j!v�r�|j5d�|�7|t9|t)|�t:t;�t:d&t:���}�qQ|�3t<�D]0}td.�}|�7||�} | �8|�}||j!v�r�|j5d�|�7|t9|t)|�t:t;�t:���}�q��qE|du�r�|�#|��j|
g|g��%�}
|
�%�}t
|t&��s�|}
�q�t|�d
k�r�|}
�q�t|�dk�r�|\�
��nt|�d&k�r|\�
�d�nt�|�r(t
�t=��r�jd6i����t
�t=��r(�jd6i����|j1�rKt|j>�}!|!�?�
�|�@�}|�A�
���}
tB|
g|!�R�}
�q�d/d0���fd1d2��ggg}"}#}$t9�C|�D]5}%t��
fd3d�tD�C|%�D���r{|"�#|%��qbtd4d�tD�C|%�D���r�|$�#t.|%���qb|#�#|%��qbt9����
fd5d%�|"D��}&zt9|#��A�
���}'t.t9|$���A�
���}(|&|'|(}
W�q�t�y�|�#|��j|
g|g�}
|
�%�}t
|t&��s�|}
Y�q�w|
S)7a
        Perform the integration using any hints given.

        Examples
        ========

        >>> from sympy import Piecewise, S
        >>> from sympy.abc import x, t
        >>> p = x**2 + Piecewise((0, x/t < 0), (1, True))
        >>> p.integrate((t, S(4)/5, 1), (x, -1, 1))
        1/3

        See Also
        ========

        sympy.integrals.trigonometry.trigintegrate
        sympy.integrals.heurisch.heurisch
        sympy.integrals.rationaltools.ratint
        as_sum : Approximate the integral using a sum
        r��Sum�	integralsT�deep�meijergN�conds�	piecewise�risch�heurisch�manualrPz;At most one of manual, meijerg, risch, heurisch can be TrueF�r�r�r�r�r�)�separater��nonez=conds must be one of "separate", "piecewise", "none", got: %scss�|]	}t|�dkVqdS)rPN�rSrErBrBrC�	<genexpr>���z Integral.doit.<locals>.<genexpr>z4risch=True is only allowed for indefinite integrals.c3s �|]}|�jjdvVqdS�rN)r>rI�rFrjrJrBrCr��s�z3Limit of the sum cannot be an integration variable.cs��|]}|jVqdS�N)�is_infinite�rFrXrBrBrCr����cs��|�j�jdi���S)NrB)r�rI�doit)r�)�hintsrKrBrC�<lambda>�szIntegral.doit.<locals>.<lambda>rOcsr�r�)�is_nonnegative�rFr[rBrBrCr��r�)�positivecsr�r�)�is_nonpositiver�rBrBrCr��r�)�negativecsr�r�)�is_realr�rBrBrCr��r�)�realcSsi|]\}}||�qSrBrBrhrBrBrC�
<dictcomp>�roz!Integral.doit.<locals>.<dictcomp>crkrB)r�r�)�undorBrCrH�roz!Integral.doit.<locals>.<listcomp>rQc3s�|]	}|d�vVqdSr�rBr�)�ulirBrCr��r�csr�r�)�is_extended_real�rFr�rBrBrCr�r�css�|]
}|jo
|jVqdSr�)r�r�r�rBrBrCr�	s���xrc
s�d}t|�dkrg�durg|\}}}z	t||||�}Wnty/ddlm}|d�d}Ynw|durg|\}}	�dkrNt||	f��||||f�df�}|S�dkret�j�d	kr_tt	d
���||	f}|S|}|S)NrOFr��_debug�+NotImplementedError from meijerint_definiter�Tr�rPz�
                                        conds=separate not supported in
                                        multiple integrals)
rSr!�NotImplementedError�sympy.integrals.meijerintr�rr�rIr|r+)
r>rG�retr�rvrw�resr�r��cond)r�r�rKrBrC�try_meijerg$s:
�
�����z"Integral.doit.<locals>.try_meijerg�final�x1cs"t|t�ot�fdd�|jD��S)Nc3s�|]}|�fkVqdSr�rBr��r�rBrCr��s�z6Integral.doit.<locals>.is_indef_int.<locals>.<genexpr>)r:r-�anyrI)�gr�rBr�rC�is_indef_int�s
�z#Integral.doit.<locals>.is_indef_intcsFg}t�|�D]}�||�r|�|�|||��q|�|�qt|�Sr�)r
�	make_argsr��_eval_interval)r�r�rvrw�argsr�)r�rBrC�
eval_factored�s
z$Integral.doit.<locals>.eval_factoredc3s�|]}�|��VqdSr�rB�rFr�)r�r�rBrCr�����css�|]}t|t�VqdSr�)r:rr�rBrBrCr��r�csg|]	}�|�����qSrBrB)rFr�)rvrwr�r�rBrCrH�s�rB)E�sympy.concrete.summationsr��getrSr{�filterr|�dictr�rIrRr�Zeror:r>r�r�r�r#�	applyfuncr(r��	integrate�allr�rr�r�r�r��typerD�setrM�unionr�rV�factorr-�hasrr�rewriterrrr�_eval_integralr��is_Polyr�atomsrr�rrcrrrrrr�gens�remove�as_exprr�r$r�r
))rKr�r�r�r�r�r��eval_kwargs�_i�_sumr>rGrnrXr_�did�
undone_limits�ulj�factored_functionr��	antiderivr��meijerg1r�r��	atan_term�atan_arg�tan_partr��tan_exp1�coeff�cot_part�cot_exp1r�r��others�
piecewisesr��uneval�evalued�
evalued_pwrB)rvrwr�r�r�r�r�rKr�r�r�rCr�xs�
��".
�


�
�&

"

��
����
&���

	��






��


���





�
��
��z
Integral.doitcs �jt�j�}}|�d�}t|�dkr|\�}}nt|�dkr'|\�}d}nd}}|d�|r<�j|gt|��R�}���fdd�}tj}|durR||||�7}|dur]||||�8}t|�dkro��kro|}	||	7}|St	d	�}
|�
�|
�����
|
��}	|	r�|��|	t�||��7}|S)
a�Evaluate the derivative of the current Integral object by
        differentiating under the integral sign [1], using the Fundamental
        Theorem of Calculus [2] when possible.

        Explanation
        ===========

        Whenever an Integral is encountered that is equivalent to zero or
        has an integrand that is independent of the variable of integration
        those integrals are performed. All others are returned as Integral
        instances which can be resolved with doit() (provided they are integrable).

        References
        ==========

        .. [1] https://en.wikipedia.org/wiki/Differentiation_under_the_integral_sign
        .. [2] https://en.wikipedia.org/wiki/Fundamental_theorem_of_calculus

        Examples
        ========

        >>> from sympy import Integral
        >>> from sympy.abc import x, y
        >>> i = Integral(x + y, y, (y, 1, x))
        >>> i.diff(x)
        Integral(x + y, (y, x)) + Integral(1, y, (y, 1, x))
        >>> i.doit().diff(x) == i.diff(x).doit()
        True
        >>> i.diff(y)
        0

        The previous must be true since there is no y in the evaluated integral:

        >>> i.free_symbols
        {x}
        >>> i.doit()
        2*x**3/3 - x/2 - 1/6

        ���rOrQNrcsVt|��}|s
tjSt|t�r#�fdd�|jD�}�j|jg|�R�}|��|�|S)Ncs0g|]}t|�dkr|d�kr��fn|�qS)rPrr�r�r�rBrCrHs(�z:Integral._eval_derivative.<locals>._do.<locals>.<listcomp>)	rrr�r:r-rIr�r>rc)r��ab�dab_dsymrI�rKr�r�rBrC�_dos


�z&Integral._eval_derivative.<locals>._dorPr�)
r>r{rIr�rSr�rDrr�rrcrr)rKr�r�rIr&rvrwr��rv�argr�rBr�rC�_eval_derivative�s4-


�zIntegral._eval_derivativeNr�c	"
spddlm}	ddlm}
ddlm}m}ddlm}
ddl	m
}|r5z||||d�WSty4YdSw|rVzt||�}|durI|j
tkrI|WSWnttfyUYnwt|||||d	�}t|t�ry|sy|sy|sytd
ddd
d���|�|�St|t�r�|j|fi|��S|�|�s�||S|�|�}|dur�|s�|s�|s�|����S|dur�z|||d|d�\}}Wn	ty�Yn w|r�|dkr�ddl	m}|||�jdd�S||jdd�S|Sg}t�|�}|D�]K}|� |�\}}|t!j"u�r|�s|�#||�q�|�$�}|du�rC|j%|�&�|fi|��}|du�r@|j%|j'|fi|��}|du�r@|j
|g|j(�R�}|�#|||�q�dS|j)�r�|j*�|��s�|�s�t+d|gd�}t+d|gd�}|j,�-|||�}|du�r�|j*dk�rzt.|j,�}n2|dk�r�|j,|j*d|j*d}nt.|j,�}|j,|j*d|j*d} t| t/|j*d�f|df�}|�#||||�q�|�0|��r�|�s�|�s�|�s�|�#||
||��q�|�sm|�sm|�smt1|||d�}|du�r�|�#||�q�|	||�}|du�r|�#||�q�|
||�}|du�r|�#||�q�|du�rDz|||d|d�\}}Wnt�y0d}Ynw|�r<||jdd�}|�#||�q�|du�rlz|dk�rW|||gd�}n|||gd�}Wnt�ykd}Ynwnd}|du�r�|du�r�zt2||�}Wnt�y�ddl3m4}!|!d�Ynw|du�r�|�#||�q�|du�r|du�rzHt||�}|du�r�t|t��s�|�t��r�|�s�|�d�d<d�d<|j
�fdd �|j5D��j6ddddd!�}|�t��s�|�#||�Wq�Wnttf�yYnw|�s$t7|�dk�r$t8|�j6ddd"�}|j9�r$|j%||fi|��S|du�r1|�#||�q�dSt|�S)#a�
        Calculate the anti-derivative to the function f(x).

        Explanation
        ===========

        The following algorithms are applied (roughly in this order):

        1. Simple heuristics (based on pattern matching and integral table):

           - most frequently used functions (e.g. polynomials, products of
             trig functions)

        2. Integration of rational functions:

           - A complete algorithm for integrating rational functions is
             implemented (the Lazard-Rioboo-Trager algorithm).  The algorithm
             also uses the partial fraction decomposition algorithm
             implemented in apart() as a preprocessor to make this process
             faster.  Note that the integral of a rational function is always
             elementary, but in general, it may include a RootSum.

        3. Full Risch algorithm:

           - The Risch algorithm is a complete decision
             procedure for integrating elementary functions, which means that
             given any elementary function, it will either compute an
             elementary antiderivative, or else prove that none exists.
             Currently, part of transcendental case is implemented, meaning
             elementary integrals containing exponentials, logarithms, and
             (soon!) trigonometric functions can be computed.  The algebraic
             case, e.g., functions containing roots, is much more difficult
             and is not implemented yet.

           - If the routine fails (because the integrand is not elementary, or
             because a case is not implemented yet), it continues on to the
             next algorithms below.  If the routine proves that the integrals
             is nonelementary, it still moves on to the algorithms below,
             because we might be able to find a closed-form solution in terms
             of special functions.  If risch=True, however, it will stop here.

        4. The Meijer G-Function algorithm:

           - This algorithm works by first rewriting the integrand in terms of
             very general Meijer G-Function (meijerg in SymPy), integrating
             it, and then rewriting the result back, if possible.  This
             algorithm is particularly powerful for definite integrals (which
             is actually part of a different method of Integral), since it can
             compute closed-form solutions of definite integrals even when no
             closed-form indefinite integral exists.  But it also is capable
             of computing many indefinite integrals as well.

           - Another advantage of this method is that it can use some results
             about the Meijer G-Function to give a result in terms of a
             Piecewise expression, which allows to express conditionally
             convergent integrals.

           - Setting meijerg=True will cause integrate() to use only this
             method.

        5. The "manual integration" algorithm:

           - This algorithm tries to mimic how a person would find an
             antiderivative by hand, for example by looking for a
             substitution or applying integration by parts. This algorithm
             does not handle as many integrands but can return results in a
             more familiar form.

           - Sometimes this algorithm can evaluate parts of an integral; in
             this case integrate() will try to evaluate the rest of the
             integrand using the other methods here.

           - Setting manual=True will cause integrate() to use only this
             method.

        6. The Heuristic Risch algorithm:

           - This is a heuristic version of the Risch algorithm, meaning that
             it is not deterministic.  This is tried as a last resort because
             it can be very slow.  It is still used because not enough of the
             full Risch algorithm is implemented, so that there are still some
             integrals that can only be computed using this method.  The goal
             is to implement enough of the Risch and Meijer G-function methods
             so that this can be deleted.

             Setting heurisch=True will cause integrate() to use only this
             method. Set heurisch=False to not use it.

        r)�deltaintegrate)�singularityintegrate)r��heurisch_wrapper)�ratint)�risch_integrate)r�Nr�r0r1r2r3r4FT)�separate_integralr�)�NonElementaryIntegral)r�rv)�excluderwr�r�rP)r�r�r�r�r�cs*g|]}|�t�r|jdi���n|�qS�rB)r�r-r�)rFr��new_eval_kwargsrBrCrHRs���z+Integral._eval_integral.<locals>.<listcomp>)�multinomialr�	power_exp�
power_base)�mulr�):�sympy.integrals.deltafunctionsr�$sympy.integrals.singularityfunctionsr�sympy.integrals.heurischr�r�sympy.integrals.rationaltoolsr�sympy.integrals.rischrr�rr�r-r|r%r�r:r$r,r;r�r�piecewise_integrater��as_polyr�r	r�rr��as_independentr�Oner��getOr��removeO�exprr��is_Pow�expr�base�matchrr
�is_rational_functionr r"r�r�r��expandrSr)�is_Add)"rKr�r�r�r�r�r�r�r�rr�	heurisch_rrr�resultr��polyr[r	�partsr�r�r��
order_term�h�h_order_expr�h_order_termrvrw�M�h1�h2r�rBrrCr�!sP[�
���	�



��




��








��

����

����
zIntegral._eval_integralrccsb�|��}|}|jD]}||dd�vr|d}nq
|j�||�D]}t|g|j�R�Vq"dS)NrPr)�as_dummyrIr>�lseriesr�)rKr��logx�cdirr�symbrX�termrBrBrC�
_eval_lseries{s�
��zIntegral._eval_lseriesc	s�|��}��|jD]}�|dd�vr|d�nq	|jj�||d��t�\}}��fdd�|D�}t|g|j�R�t|��S)NrPr)r��nr2csg|]}|�����qSrBrb)rF�o�r4r�rBrCrH�rgz*Integral._eval_nseries.<locals>.<listcomp>)r0rIr>�nseries�as_coeff_addr'r�r)	rKr�r7r2r3rrX�terms�orderrBr9rC�
_eval_nseries�s
���zIntegral._eval_nseriescCs@|jd�|�}|D]}|dkrnq
t|g|jdd��R�S)NrrP)r�r1r�)rKr�r2r3�
series_gen�leading_termrBrBrC�_eval_as_leading_term�s�zIntegral._eval_as_leading_termcsVddlm}ddlm�||�}t|t�r#|j��fdd�|jD��S|jdi���S)Nr)�factor_terms)�simplifycsg|]
}�|fi����qSrBrBr���kwargsrCrBrCrH�sz+Integral._eval_simplify.<locals>.<listcomp>rB)�sympy.core.exprtoolsrB�sympy.simplify.simplifyrCr:r-r�r�)rKrErBrrBrDrC�_eval_simplify�s
zIntegral._eval_simplify�midpointTc	Cs�ddlm}|j}t|�dkrtd��|d}t|�dks+|djdus+|djdur/td��|d	ur;td
ddd�}nt|�}|j	dusN|j
dusN|jdurTtd
|��|\}}}	|	||}
tdddd�}|j}|dkr�|
||�|||d|
�|d|f�}
n_|dkr�|
||�||||
�|d|f�}
nH|dkr�|
||�||||
|
d�|d|f�}
n-|dkr�|
|�||�|�||	�d||�||||
�|d|df�}
ntd|��|r�|
�
�S|
S)a@
        Approximates a definite integral by a sum.

        Parameters
        ==========

        n :
            The number of subintervals to use, optional.
        method :
            One of: 'left', 'right', 'midpoint', 'trapezoid'.
        evaluate : bool
            If False, returns an unevaluated Sum expression. The default
            is True, evaluate the sum.

        Notes
        =====

        These methods of approximate integration are described in [1].

        Examples
        ========

        >>> from sympy import sin, sqrt
        >>> from sympy.abc import x, n
        >>> from sympy.integrals import Integral
        >>> e = Integral(sin(x), (x, 3, 7))
        >>> e
        Integral(sin(x), (x, 3, 7))

        For demonstration purposes, this interval will only be split into 2
        regions, bounded by [3, 5] and [5, 7].

        The left-hand rule uses function evaluations at the left of each
        interval:

        >>> e.as_sum(2, 'left')
        2*sin(5) + 2*sin(3)

        The midpoint rule uses evaluations at the center of each interval:

        >>> e.as_sum(2, 'midpoint')
        2*sin(4) + 2*sin(6)

        The right-hand rule uses function evaluations at the right of each
        interval:

        >>> e.as_sum(2, 'right')
        2*sin(5) + 2*sin(7)

        The trapezoid rule uses function evaluations on both sides of the
        intervals. This is equivalent to taking the average of the left and
        right hand rule results:

        >>> e.as_sum(2, 'trapezoid')
        2*sin(5) + sin(3) + sin(7)
        >>> (e.as_sum(2, 'left') + e.as_sum(2, 'right'))/2 == _
        True

        Here, the discontinuity at x = 0 can be avoided by using the
        midpoint or right-hand method:

        >>> e = Integral(1/sqrt(x), (x, 0, 1))
        >>> e.as_sum(5).n(4)
        1.730
        >>> e.as_sum(10).n(4)
        1.809
        >>> e.doit().n(4)  # the actual value is 2
        2.000

        The left- or trapezoid method will encounter the discontinuity and
        return infinity:

        >>> e.as_sum(5, 'left')
        zoo

        The number of intervals can be symbolic. If omitted, a dummy symbol
        will be used for it.

        >>> e = Integral(x**2, (x, 0, 2))
        >>> e.as_sum(n, 'right').expand()
        8/3 + 4/n + 4/(3*n**2)

        This shows that the midpoint rule is more accurate, as its error
        term decays as the square of n:

        >>> e.as_sum(method='midpoint').expand()
        8/3 - 2/(3*_n**2)

        A symbolic sum is returned with evaluate=False:

        >>> e.as_sum(n, 'midpoint', evaluate=False)
        2*Sum((2*_k/n - 1/n)**2, (_k, 1, n))/n

        See Also
        ========

        Integral.doit : Perform the integration using any hints

        References
        ==========

        .. [1] https://en.wikipedia.org/wiki/Riemann_sum#Methods
        rr�rPz2Multidimensional midpoint rule not implemented yetrOFrQz5Expecting a definite integral over a finite interval.Nr7T)�integerr�z$n must be a positive integer, got %sri�left�rightrI�	trapezoidzUnknown method %s)r�r�rIrSr�rtr|rr�is_positive�
is_integerr>rcr�)rKr7�method�evaluater�rIr&r�rvrw�dxrir�r&rBrBrC�as_sum�s@i�

*&."�zIntegral.as_sumc	sdddlm}t|j�dkstt|jd��dkrtd��|jd\}���jr.�jr.��ks2td����kr8dStd�}|j}��fdd	�|||�D�}|D]}|�ksX|�kr^td
|��qNt	||fi|��}|�
t�ro|S�tur��tur�t
||�||�|t�}	nt
||�d�t
||�d�}	|D]}
|	t
|�||
|�|�||
|�|dd�7}	q�|	S)
a
        Compute the Cauchy Principal Value of the definite integral of a real function in the given interval
        on the real axis.

        Explanation
        ===========

        In mathematics, the Cauchy principal value, is a method for assigning values to certain improper
        integrals which would otherwise be undefined.

        Examples
        ========

        >>> from sympy import oo
        >>> from sympy.integrals.integrals import Integral
        >>> from sympy.abc import x
        >>> Integral(x+1, (x, -oo, oo)).principal_value()
        oo
        >>> f = 1 / (x**3)
        >>> Integral(f, (x, -oo, oo)).principal_value()
        0
        >>> Integral(f, (x, -10, 10)).principal_value()
        0
        >>> Integral(f, (x, -10, oo)).principal_value() + Integral(f, (x, -oo, 10)).principal_value()
        0

        References
        ==========

        .. [1] https://en.wikipedia.org/wiki/Cauchy_principal_value
        .. [2] http://mathworld.wolfram.com/CauchyPrincipalValue.html
        r)�
singularitiesrPrOzkYou need to insert a variable, lower_limit, and upper_limit correctly to calculate cauchy's principal valuez�The lower_limit must be smaller than or equal to the upper_limit to calculate cauchy's principal value. Also, a and b need to be comparable.�rcs.g|]}|jr�|kr�krnn|�qSrB)�
is_comparablerlr~rBrCrH[s.z,Integral.principal_value.<locals>.<listcomp>zRThe principal value is not defined in the given interval due to singularity at %d.�-�+)�sympy.calculusrTrSrIr{r|rVrr>r�r�r-rr&rc)rKrErTr�rUr��singularities_listr[ru�IrmrBr~rC�principal_value.s4!$��
0zIntegral.principal_value)NNNNr�N)Nr)NrIT)�__name__�
__module__�__qualname__�__doc__�	__slots__r<rL�propertyrMr\r�r�rr�r6r>rArHrSr\rBrBrBrCr-"s47
#\N]
�
\



	r-Nr�)r�r�r�r�r�c	sXd|||||d��t|i|��}t|t�r|jdi���S�fdd�|jD�}|j|�S)a�integrate(f, var, ...)

    Explanation
    ===========

    Compute definite or indefinite integral of one or more variables
    using Risch-Norman algorithm and table lookup. This procedure is
    able to handle elementary algebraic and transcendental functions
    and also a huge class of special functions, including Airy,
    Bessel, Whittaker and Lambert.

    var can be:

    - a symbol                   -- indefinite integration
    - a tuple (symbol, a)        -- indefinite integration with result
                                    given with `a` replacing `symbol`
    - a tuple (symbol, a, b)     -- definite integration

    Several variables can be specified, in which case the result is
    multiple integration. (If var is omitted and the integrand is
    univariate, the indefinite integral in that variable will be performed.)

    Indefinite integrals are returned without terms that are independent
    of the integration variables. (see examples)

    Definite improper integrals often entail delicate convergence
    conditions. Pass conds='piecewise', 'separate' or 'none' to have
    these returned, respectively, as a Piecewise function, as a separate
    result (i.e. result will be a tuple), or not at all (default is
    'piecewise').

    **Strategy**

    SymPy uses various approaches to definite integration. One method is to
    find an antiderivative for the integrand, and then use the fundamental
    theorem of calculus. Various functions are implemented to integrate
    polynomial, rational and trigonometric functions, and integrands
    containing DiracDelta terms.

    SymPy also implements the part of the Risch algorithm, which is a decision
    procedure for integrating elementary functions, i.e., the algorithm can
    either find an elementary antiderivative, or prove that one does not
    exist.  There is also a (very successful, albeit somewhat slow) general
    implementation of the heuristic Risch algorithm.  This algorithm will
    eventually be phased out as more of the full Risch algorithm is
    implemented. See the docstring of Integral._eval_integral() for more
    details on computing the antiderivative using algebraic methods.

    The option risch=True can be used to use only the (full) Risch algorithm.
    This is useful if you want to know if an elementary function has an
    elementary antiderivative.  If the indefinite Integral returned by this
    function is an instance of NonElementaryIntegral, that means that the
    Risch algorithm has proven that integral to be non-elementary.  Note that
    by default, additional methods (such as the Meijer G method outlined
    below) are tried on these integrals, as they may be expressible in terms
    of special functions, so if you only care about elementary answers, use
    risch=True.  Also note that an unevaluated Integral returned by this
    function is not necessarily a NonElementaryIntegral, even with risch=True,
    as it may just be an indication that the particular part of the Risch
    algorithm needed to integrate that function is not yet implemented.

    Another family of strategies comes from re-writing the integrand in
    terms of so-called Meijer G-functions. Indefinite integrals of a
    single G-function can always be computed, and the definite integral
    of a product of two G-functions can be computed from zero to
    infinity. Various strategies are implemented to rewrite integrands
    as G-functions, and use this information to compute integrals (see
    the ``meijerint`` module).

    The option manual=True can be used to use only an algorithm that tries
    to mimic integration by hand. This algorithm does not handle as many
    integrands as the other algorithms implemented but may return results in
    a more familiar form. The ``manualintegrate`` module has functions that
    return the steps used (see the module docstring for more information).

    In general, the algebraic methods work best for computing
    antiderivatives of (possibly complicated) combinations of elementary
    functions. The G-function methods work best for computing definite
    integrals from zero to infinity of moderately complicated
    combinations of special functions, or indefinite integrals of very
    simple combinations of special functions.

    The strategy employed by the integration code is as follows:

    - If computing a definite integral, and both limits are real,
      and at least one limit is +- oo, try the G-function method of
      definite integration first.

    - Try to find an antiderivative, using all available methods, ordered
      by performance (that is try fastest method first, slowest last; in
      particular polynomial integration is tried first, Meijer
      G-functions second to last, and heuristic Risch last).

    - If still not successful, try G-functions irrespective of the
      limits.

    The option meijerg=True, False, None can be used to, respectively:
    always use G-function methods and no others, never use G-function
    methods, or use all available methods (in order as described above).
    It defaults to None.

    Examples
    ========

    >>> from sympy import integrate, log, exp, oo
    >>> from sympy.abc import a, x, y

    >>> integrate(x*y, x)
    x**2*y/2

    >>> integrate(log(x), x)
    x*log(x) - x

    >>> integrate(log(x), (x, 1, a))
    a*log(a) - a + 1

    >>> integrate(x)
    x**2/2

    Terms that are independent of x are dropped by indefinite integration:

    >>> from sympy import sqrt
    >>> integrate(sqrt(1 + x), (x, 0, x))
    2*(x + 1)**(3/2)/3 - 2/3
    >>> integrate(sqrt(1 + x), x)
    2*(x + 1)**(3/2)/3

    >>> integrate(x*y)
    Traceback (most recent call last):
    ...
    ValueError: specify integration variables to integrate x*y

    Note that ``integrate(x)`` syntax is meant only for convenience
    in interactive sessions and should be avoided in library code.

    >>> integrate(x**a*exp(-x), (x, 0, oo)) # same as conds='piecewise'
    Piecewise((gamma(a + 1), re(a) > -1),
        (Integral(x**a*exp(-x), (x, 0, oo)), True))

    >>> integrate(x**a*exp(-x), (x, 0, oo), conds='none')
    gamma(a + 1)

    >>> integrate(x**a*exp(-x), (x, 0, oo), conds='separate')
    (gamma(a + 1), -re(a) < 1)

    See Also
    ========

    Integral, Integral.doit

    F)r�r�r�r�r�r�cs*g|]}t|t�r|jdi���n|�qSr)r:r-r�)rFrv��
doit_flagsrBrCrHs"�zintegrate.<locals>.<listcomp>NrB)r-r:r�r�r�)	r�r�r�r�r�r�rE�integral�new_argsrBrcrCr�ms�

�
r�cCs�ddlm}t|�}|std��t||�std��t|�s!td��t|j�t|�kr.td��|j|vr7td��|}d}t	|�D]\}}|j|}	t
|	|j�}
||
|
}|�||	�}q?|t|�}t
||j�jdd	�}|S)
a�line_integrate(field, Curve, variables)

    Compute the line integral.

    Examples
    ========

    >>> from sympy import Curve, line_integrate, E, ln
    >>> from sympy.abc import x, y, t
    >>> C = Curve([E**t + 1, E**t - 1], (t, 0, ln(2)))
    >>> line_integrate(x + y, C, [x, y])
    3*sqrt(2)

    See Also
    ========

    sympy.integrals.integrals.integrate, Integral
    r)�Curvez6Expecting function specifying field as first argument.z*Expecting Curve entity as second argument.z)Expecting ordered iterable for variables.z3Field variable size does not match curve dimension.z.Curve parameter clashes with field parameters.F)r�)�sympy.geometryrgrr|r:rrS�	functions�	parameter�	enumeraterrcrr-rIr�)�field�curve�varsrgru�Ft�dldtr[�var�_f�_dnrerBrBrC�line_integrates0�


rtcCs
t|j�Sr�)r*r>)rrBrBrC�_Ks
ru)O�sympy.concrete.expr_with_limitsr�sympy.core.addr�sympy.core.basicr�sympy.core.compatibilityr�sympy.core.containersr�sympy.core.exprr�sympy.core.functionr�sympy.core.logicr	�sympy.core.mulr
�sympy.core.numbersrr�sympy.core.relationalr
�sympy.core.singletonr�sympy.core.symbolrrr�sympy.core.sympifyr�sympy.functionsrrrrrr�&sympy.functions.elementary.exponentialr�#sympy.functions.elementary.integersr�$sympy.functions.elementary.complexesrr�(sympy.functions.elementary.miscellaneousrr�sympy.integrals.manualintegrater�sympy.integrals.trigonometryr r�r!r"�sympy.matricesr#�sympy.polysr$r%�sympy.seriesr&�sympy.series.orderr'�sympy.series.formalr(�sympy.simplify.fur)�sympy.tensor.functionsr*�sympy.utilities.miscr+�sympy.utilities.exceptionsr,r-r�rt�registerrurBrBrBrC�<module>s^ U+4

Youez - 2016 - github.com/yon3zu
LinuXploit