403Webshell
Server IP : 93.86.61.54  /  Your IP : 216.73.216.206
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__/heurisch.cpython-310.pyc
o

�8Va�c�@stddlmZmZddlmZddlmZddlmZddl	m
Z
ddlmZddl
mZmZddl	mZdd	lmZmZmZdd
lmZmZddlmZddlmZmZmZmZmZm Z m!Z!dd
lm"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(ddlm)Z)m*Z*m+Z+m,Z,m-Z-ddlm.Z.m/Z/m0Z0m1Z1ddlm2Z2m3Z3m4Z4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:m;Z;ddl<m=Z=ddl>m?Z?m@Z@ddlAmBZBddlCmDZDmEZEddlFmGZGddlHmIZImJZJddlKmLZLddlMmNZNmOZOmPZPmQZQmRZRmSZSddlTmUZUddlVmWZWddlXmYZYddlZm[Z[ddl\m]Z]ddl^m_Z_dd l`maZad!d"�ZbiZcd#d$�Zd	'	&	&d0d(d)�ZeGd*d+�d+�Zfd&agGd,d-�d-�Zh	'	&	&d0d.d/�Zid&S)1�)�Dict�List)�permutations)�reduce)�Add)�Basic)�Mul)�Wild�Dummy)�sympify)�Rational�pi�I)�Eq�Ne)�S)�exp�sin�cos�tan�cot�asin�atan)�log�sinh�cosh�tanh�coth�asinh�acosh)�sqrt�erf�erfi�li�Ei)�besselj�bessely�besseli�besselk)�hankel1�hankel2�jn�yn)�Abs�re�im�sign�arg)�LambertW)�floor�ceiling)�	Piecewise)�	Heaviside�
DiracDelta)�collect)�And�Or)�uniq)�quo�gcd�lcm�factor�cancel�PolynomialError)�
itermonomials)�root_factors)�PolyRing)�
solve_lin_sys)�construct_domain)�ordered)�	integratecCs�t�}||jvrk|jr|jr|�|�|S|js|jr/|jD]	}|t||�O}q|�|�|S|j	r^|t|j
|�O}|jjs\|jj
rQ|�|j
td|jj��|S|t|j|�|hBO}|S|jD]	}|t||�O}qa|S)a�
    Returns a set of all functional components of the given expression
    which includes symbols, function applications and compositions and
    non-integer powers. Fractional powers are collected with
    minimal, positive exponents.

    Examples
    ========

    >>> from sympy import cos, sin
    >>> from sympy.abc import x
    >>> from sympy.integrals.heurisch import components

    >>> components(sin(x)*cos(x)**2, x)
    {x, sin(x), cos(x)}

    See Also
    ========

    heurisch
    �)�set�free_symbols�	is_symbol�is_commutative�add�is_Function�
is_Derivative�args�
components�is_Pow�baser�
is_Integer�is_Rationalr�q)�f�x�result�g�r\�:/usr/lib/python3/dist-packages/sympy/integrals/heurisch.pyrR+s*

�


��
�rRcCsjzt|}Wntyg}|t|<Ynwt|�|kr/|�td|t|�f��t|�|ks|d|�S)z*get vector of symbols local to this modulez%s%iN)�_symbols_cache�KeyError�len�appendr
)�name�n�lsymsr\r\r]�_symbols^s��reFN�c	s$ddlm}	m}
t|�}||jvr||St|||||||||�	}t|t�s(|Sg}|
|�D]}
z||	|
d|fd�7}Wq.tyEYq.w|sJ|St	t
|��}g�|
|�D]}
z�|	|
d|fd�7�WqVtymYqVw�fdd�|D�}|s{|St|�dkr�g}|D]}|�dd�|�
�D��q�|	|d|fd�|}g}|D]:}t|�|�||||||||�	}td	d�|�
�D��}td
d�|�
�D��}|dur�t|�|�|�}|�||f�q�t|�dkr�t|||||||||�	|f|dddfg}t|�S|�t|||||||||�	df�t|�S)a�
    A wrapper around the heurisch integration algorithm.

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

    This method takes the result from heurisch and checks for poles in the
    denominator. For each of these poles, the integral is reevaluated, and
    the final integration result is given in terms of a Piecewise.

    Examples
    ========

    >>> from sympy.core import symbols
    >>> from sympy.functions import cos
    >>> from sympy.integrals.heurisch import heurisch, heurisch_wrapper
    >>> n, x = symbols('n x')
    >>> heurisch(cos(n*x), x)
    sin(n*x)/n
    >>> heurisch_wrapper(cos(n*x), x)
    Piecewise((sin(n*x)/n, Ne(n, 0)), (x, True))

    See Also
    ========

    heurisch
    r)�solve�denomsT)�dict�excludecsg|]}|�vr|�qSr\r\)�.0�s��slns0r\r]�
<listcomp>��z$heurisch_wrapper.<locals>.<listcomp>rIcS�g|]	\}}t||��qSr\�r�rk�key�valuer\r\r]ro��cSrqr\rrrsr\r\r]ro�rvcSrqr\)rrsr\r\r]ro�rvN)�sympy.solvers.solversrgrhrrK�heurisch�
isinstancer�NotImplementedError�listr;r`�extend�items�subsr9r:rHrar5)rXrY�rewrite�hints�mappings�retries�
degree_offset�unnecessary_permutations�
_try_heurischrgrh�res�slns�d�eqs�sub_dict�pairs�expr�cond�genericr\rmr]�heurisch_wrapperls|
�
������
���r�c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�BesselTablez~
    Derivatives of Bessel functions of orders n and n-1
    in terms of each other.

    See the docstring of DiffCache.
    cCs&i|_td�|_td�|_|��dS)Nrc�z)�tabler
rcr��
_create_table)�selfr\r\r]�__init__�s

zBesselTable.__init__cCsh|j|j|j}}}ttttfD]&}||d|�||||�||d||d|�||||�f||<qt}||d|�||||�||d||d|�||||�f||<t}||d|�||||�||d||d|�||||�f||<t	t
fD](}||d|�|d|||�||d||d|�||||�f||<q�dS)NrI)r�rcr�r%r&r)r*r'r(r+r,)�tr�rcr�rXr\r\r]r��s$"
�"� "�""
��zBesselTable._create_tablecCsD||jvr |j|\}}|j|f|j|fg}|�|�|�|�fSdS�N)r�rcr�r~)r�rXrcr��diff0�diff1�replr\r\r]�diffs�s

�zBesselTable.diffscCs
||jvSr�)r�)r�rXr\r\r]�has��
zBesselTable.hasN)�__name__�
__module__�__qualname__�__doc__r�r�r�r�r\r\r\r]r��sr�c@s eZdZdZdd�Zdd�ZdS)�	DiffCacheau
    Store for derivatives of expressions.

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

    The standard form of the derivative of a Bessel function of order n
    contains two Bessel functions of orders n-1 and n+1, respectively.
    Such forms cannot be used in parallel Risch algorithm, because
    there is a linear recurrence relation between the three functions
    while the algorithm expects that functions and derivatives are
    represented in terms of algebraically independent transcendentals.

    The solution is to take two of the functions, e.g., those of orders
    n and n-1, and to express the derivatives in terms of the pair.
    To guarantee that the proper form is used the two derivatives are
    cached as soon as one is encountered.

    Derivatives of other functions are also cached at no extra cost.
    All derivatives are with respect to the same variable `x`.
    cCsi|_||_ts
t�adSdSr�)�cacherY�
_bessel_tabler�)r�rYr\r\r]r�	s

�zDiffCache.__init__cCs�|j}||vr	||St|d�rt�|j�s%t|�|j��||<||S|j\}}t�	|j||�\}}|�
|�}||||<||||�|d|�<||S)N�funcrI)r��hasattrr�r�r�r@�diffrYrQr��get_diff)r�rXr�rcr��d0�d1�dzr\r\r]r�s
�
�
�
zDiffCache.get_diffN)r�r�r�r�r�r�r\r\r\r]r��sr�c	*
s@
t|�}|dur|�tttttttt	t
�	rdS�|jvr |�S|js+|�
��\}	}ntj}	tttfttttfti}
|rL|
��D]
\}}|�||�}q@n|
��D]	}|j|�rYnqPd}t|��}
|du�r�|�s�td�gd�}td�gd�}td�gd�}t|
�D�]*}|j�r�t|t �r�|j!d�"|�|�}|dur�|
�#�t ||�||�||�||d||t$||d	t%||�||�||��q�t|t&��r�|j!d�"|�d
�}|du�r||j'�r|
�#t(t)||����n|
�#t*t)||����|j!d�"|�d
|�|�}|du�r�||j'�re|
�#t)t+d||�t&||||d
d||�t(t)||��||d
t)||���n>||j,�r�|
�#t)t+d||�t&||||d
d||�t*t)||��||d
t)||���|j!d�"|t%��d
�}|du�r�||j'�r�|
�#t(t)||�t%��d	d
t)||���||j,�r�|
�#t*t)||�t%��d	d
t)||���q�|j-�r�|j&j.�r�|j&j/d
k�r�|j0�"|�d
|�}|du�rN||j'�rN||j'�r6|
�#t1t)||||����n||j,�rN|
�#t2t)||||����|j0�"|�d
|�}|du�r�||j'�r�||j'�r}|
�#t3t)||||����q�||j,�r�|
�#||d
t)||�t4t)||��t)||�d
||���q�n|
t|�O}
t5���t|
�D]
}|
t��6|���O}
�q�t7dt8|
���t9t:t9t;t<�fd
d�t;|
��D����d	���	dd��	D�}|du�r�	dd�k�sJ��	�=d�g}t>�	�}n|�pg}�	fdd��|D];�	t9�	��	�	|�	��fdd�|
D�}dd�|D�}t?�fdd�|D���rS�|�j@���rStA�fdd�|��n�q|�sjtB|�d||d�}|du�rj|	|SdS�fdd�|D��
��
fdd�����fdd�����fdd ��i}|
D]=}|j�r�t|t��r�d!|d	�|�d
<�q�t|t��r�d!|d	�|�<d!|d	�|�<�q�t|tC��r�d|�|�<�q��|����D�\}}���}�|�}tt9|�|dgt9|����}|dtEd"d�|��D��}�fd#d�|||fD�}d|v�rdSd$d�|D�\}}}||d�|d	��F���fd%d&���|�|tG||�} }!| d	k�rW|!d	k�rWtHt<tI�| |!d	|���}"n
tHt<tI�| |!|���}"t7d't8|"���tJ�fd(d�tK|"�D���
t��|D]@}#|#j���r�ztL|#dd)�}$WntM�y�|#}$Ynw|$jN�r�|$j!}%n|$f}%|%D]}&|&j-�r���#|&j0��q���#|&��q��q}d.�������
�fd*d+�	}'�jt���s�|'d,�}(|(du�r�|'�}(n|'�}(|(du�r|(�O|�})tP|)��Q�})|)j�r�|)�
��d	})|	|)S|dk�rtB|�||||d	|d-�}|du�r|	|SdS)/a,

    Compute indefinite integral using heuristic Risch algorithm.

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

    This is a heuristic approach to indefinite integration in finite
    terms using the extended heuristic (parallel) Risch algorithm, based
    on Manuel Bronstein's "Poor Man's Integrator".

    The algorithm supports various classes of functions including
    transcendental elementary or special functions like Airy,
    Bessel, Whittaker and Lambert.

    Note that this algorithm is not a decision procedure. If it isn't
    able to compute the antiderivative for a given function, then this is
    not a proof that such a functions does not exist.  One should use
    recursive Risch algorithm in such case.  It's an open question if
    this algorithm can be made a full decision procedure.

    This is an internal integrator procedure. You should use toplevel
    'integrate' function in most cases,  as this procedure needs some
    preprocessing steps and otherwise may fail.

    Specification
    =============

     heurisch(f, x, rewrite=False, hints=None)

       where
         f : expression
         x : symbol

         rewrite -> force rewrite 'f' in terms of 'tan' and 'tanh'
         hints   -> a list of functions that may appear in anti-derivate

          - hints = None          --> no suggestions at all
          - hints = [ ]           --> try to figure out
          - hints = [f1, ..., fn] --> we know better

    Examples
    ========

    >>> from sympy import tan
    >>> from sympy.integrals.heurisch import heurisch
    >>> from sympy.abc import x, y

    >>> heurisch(y*tan(x), x)
    y*log(tan(x)**2 + 1)/2

    See Manuel Bronstein's "Poor Man's Integrator":

    References
    ==========

    .. [1] http://www-sop.inria.fr/cafe/Manuel.Bronstein/pmint/index.html

    For more information on the implemented algorithm refer to:

    .. [2] K. Geddes, L. Stefanus, On the Risch-Norman Integration
       Method and its Implementation in Maple, Proceedings of
       ISSAC'89, ACM Press, 212-217.

    .. [3] J. H. Davenport, On the Parallel Risch Algorithm (I),
       Proceedings of EUROCAM'82, LNCS 144, Springer, 144-157.

    .. [4] J. H. Davenport, On the Parallel Risch Algorithm (III):
       Use of Tangents, SIGSAM Bulletin 16 (1982), 3-6.

    .. [5] J. H. Davenport, B. M. Trager, On the Parallel Risch
       Algorithm (II), ACM Transactions on Mathematical
       Software 11 (1985), 356-362.

    See Also
    ========

    sympy.integrals.integrals.Integral.doit
    sympy.integrals.integrals.Integral
    sympy.integrals.heurisch.components
    TN�a)rj�b�cr���rI��rYcs"g|]
}|d���d|f�qS)rrI)�as_independent)rkr�)rYr\r]ro�s"zheurisch.<locals>.<listcomp>cSsi|]\}}||�qSr\r\�rk�k�vr\r\r]�
<dictcomp>��zheurisch.<locals>.<dictcomp>cs
|���Sr�)r~�r�)�mappingr\r]�_substitute�r�zheurisch.<locals>._substitutecsg|]	}���|���qSr\)r��rkr[)r��dcacher\r]ro�rvcSsg|]}|��d�qS)rI)�as_numer_denomr�r\r\r]ro�rpc3s�|]}|j��VqdSr�)�
is_polynomial�rk�h��Vr\r]�	<genexpr>�s�zheurisch.<locals>.<genexpr>cst||g��R�Sr�)r>)�prWr�r\r]�<lambda>�szheurisch.<locals>.<lambda>)rr�r�csg|]}t�|��qSr\)r@r�)�denomr\r]rorpcst�fdd�t���D��S)Ncsg|]\}}|��|��qSr\)r�)rkr�r��r�r\r]rosz1heurisch.<locals>._derivation.<locals>.<listcomp>)r�zipr�)r��numersr�r]�_derivationszheurisch.<locals>._derivationcsZ�D](}|�|�s
q�|�tjur*|�|���\}}�|�t||�|����Sq|Sr�)r�r�Zero�as_poly�	primitiver=r��as_expr)r��yr�rW)r��
_deflationr�r\r]r�s
 �zheurisch.<locals>._deflationcs��D]f}|�|�s
q�|�tjurh|�|���\}}|��}t|�|�|�}t|t||�|�|�|�}�|�}|�|��	�dkrL|d||dfS�t
||��}|d|d||d|dfSqtj|fS)NrrI)r�rr�r�r�r�r=r<r��degreer@�One)r�r�r�rWr�rl�c_split�q_split)r�r��	_splitterr\r]r�s
(�
zheurisch.<locals>._splitterFcSsg|]\}}|r|�qSr\r\r�r\r\r]ro>rpcsg|]}|j���qSr\)r��rkr�r�r\r]ro?r�cSsg|]}|���qSr\)�total_degreer�r\r\r]roE�csz|jr)|jjr'|jjdkr'|jjdkr|jj|jjdSt|jj|jj�SdS|js;|jr;t�fdd�|jD��SdS)NrIrcsg|]}�|��qSr\r\r���	_exponentr\r]roSr�z/heurisch.<locals>._exponent.<locals>.<listcomp>)	rSrrVrWr��abs�is_AtomrQ�max)r[r�r\r]r�Iszheurisch.<locals>._exponent�Acsg|]
\}}�||�qSr\r\)rk�i�monomial)�poly_coeffsr\r]ro`s�)�greedycs�t�}t�}t�}�
D]}|jD]}|�vrnqq|tt|||d��O}qgg}}t|�D]1}t|tdd�}|�ttj�}	|	r`|�tj	tj�}
|
�
t�sS|	�
t�rTq/|�|
|	f�|�|�q/|r�|�
�\}
}	|
|	f|vr�|�|
|	f�|	��r|	}	|�|
|
|	|	�|�t|
|	��n	|�|
t|	�|sctdt|��}tdt|��}tttt|�|���D]\}}
|j
��rψ�|
�|�|
t|��q�tttt|�|���D]\}}|j
��r��|�|�||�qۈ	�t|�t|�}��|��}|��d}t��t��B�t�����fdd��z�|�Wnt�y/YdSwt�d	d
�\}}t�|�}t�|�}z|�|�}Wn
t�ySt�wt|��|dd�}|du�rddS|� |�� t!t�tjgt�����S)N)�filterF)�evaluate�B�Crcs^|js|jrdS|�vrdS|j�@s��|�dS|js#|js#|jr-tt�|j	��dSt
�r�)rUrVrKrN�is_Add�is_MulrSr{�maprQrAr���
find_non_syms�non_syms�symsr\r]r��s
z3heurisch.<locals>._integrate.<locals>.find_non_symsT)�field)�_raw)"rJrKrCr{r8r�getrr�r�r�rN�remove�pop�could_extract_minus_signrrer`�reversedr�rGrarrr�rArFrD�	from_expr�
ValueErrorrE�coeffs�xreplaceri)r��irreducibles�atansr��polyr��log_part�	atan_part�mr�rYr�r�r�r��	candidater��	raw_numer�ground�_�
coeff_ring�ring�numer�solution)�Fr�r�r�r��
poly_denom�	poly_part�
reduciblesr�r]�
_integratews�
�

��


�

��

�

�zheurisch.<locals>._integrate�Q)r�rr�r�r�r�)Rrr�r-r.r/r0r6r7r3r4r1rKr�r�rr�rrrrrrrrr}r�keysrRr	rJrOryr#rQ�matchrNr$rr�is_positiver"r r!r
�is_negativerSrVrWrTrrrrr�r�rer`r{r�r�rGr�r�all�is_rational_functionrrxr2r�rr�r��tuplerBr�	enumerater?rAr�r~r@�expand)*rXrYrr�r�r�r�r�r��indep�rewritables�
candidates�rule�termsr�r�r�r[�M�rev_mappingr�rhrZ�special�term�Pr�u_split�v_split�polysrl�polifiedr�r��monomsr��
factorization�factors�factrr�	antiderivr\)rr�r�r�r�r�r�r�r�r�r�r�rr	r
rYr]rx"sbS


��
�


r�
$
<*�<.�
26�$$$0���:
��


(�
�
�"
 ���i
�



rx)FNNrfrNN)j�typingrr�	itertoolsr�	functoolsr�sympy.core.addr�sympy.core.basicr�sympy.core.mulr�sympy.core.symbolr	r
r�sympy.core.numbersrr
r�sympy.core.relationalrr�sympy.core.singletonr�sympy.functionsrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,�$sympy.functions.elementary.complexesr-r.r/r0r1�&sympy.functions.elementary.exponentialr2�#sympy.functions.elementary.integersr3r4�$sympy.functions.elementary.piecewiser5�'sympy.functions.special.delta_functionsr6r7�sympy.simplify.radsimpr8�sympy.logic.boolalgr9r:�sympy.utilities.iterablesr;�sympy.polysr<r=r>r?r@rA�sympy.polys.monomialsrB�sympy.polys.polyrootsrC�sympy.polys.ringsrD�sympy.polys.solversrE�sympy.polys.constructorrF�sympy.core.compatibilityrG�sympy.integrals.integralsrHrRr^rer�r�r�r�rxr\r\r\r]�<module>s\$$ /
�\(0�

Youez - 2016 - github.com/yon3zu
LinuXploit