403WebShell

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/simplify/__pycache__/
Upload File :
[ Back ]
Current File : /usr/lib/python3/dist-packages/sympy/simplify/__pycache__/powsimp.cpython-310.pyc
o

�8Va�f�@s�ddlmZddlmZmZddlmZmZmZm	Z	m
Z
mZmZm
Z
mZddlmZmZmZddlmZmZddlmZmZddlmZddlmZmZmZmZm Z m!Z!dd	l"m#Z#m$Z$dd
l%m&Z&dddefd
d�Z'ddd�Z(ed�Z)dd�Z*dS)�)�defaultdict)�
expand_log�	count_ops)	�sympify�Basic�Dummy�S�Add�Mul�Pow�
expand_mul�factor_terms)�ordered�default_sort_key�reduce)�Integer�Rational)�prod�_keep_coeff)�	Transform)�	exp_polar�exp�log�root�polarify�
unpolarify)�lcm�gcd)�multiplicityF�allc5s�
ddlm}����fdd��	t|�}t|t�r*t||�s*|js*|td�td�fvr,|S�s9|js9|jrFt	|j
vrF|j�	fdd�|j
D��}|jrS�	|t	dd	�t	S|jsX|S�d
v�r�t
t�}g}g}tj}	|j
D]k}
|
jru|	|
9}	qk|
jr|t|
�}
|
jr�|
��\}}�r��	fdd�||fD�\}}|js�t|t�r�||tj}}||�|�qk|r�|d��\}
}|
��\}}|
|kr�|jr�|jr�t|
t||��|d<qk|�|
�qktt|����D]A\}}|�r|j�rtd
d�|D���s|	tju�r|tjtjfv�rtt|�t|	��}|�r|�|�|	||}	t|�||<q�|	tju�r;|	|v�r6||	tj7<ntj||	<t |�}t|���}t!�}|D]O\}}||v�rU�qJ|j"�p[|j#}|�r�d|}||k�r�||v�r�|�$�dtju�r�|�%|�|||8<�qJ|�&|�|�%|�}|||8<�qJt|���}tj}|D]X\}}|j'�s�|j�r�||v�r�||v�r�|j"du�s�|j(�r�|j(�s�|j)�r�|||�%|�7<n|�%|�}|||7<||v�r�|||7<�q�|||<�q�dd�|��D�}�fdd��d(�fdd�	����fdd�}i�g}g�|D]0\}}�||�\}}|�v�r=�||�|<n|�|<|ddk�rS|dj�rS��|��q$�j*t+d��j*�dd��D]�}|�v�rm�qd|\}}d}d}	|}|}g}g} t,�-|�D])}!�|!�\}"}#|"�v�s��|"|#k�r�g} }n| �|#�|"g�|�|"��q�| �r| dd| dd}$t.dt/| ��D]}%| |%d| |%d}&|&dk�r�n3t0|$|&�}$�q�t.t/|��D]}%�||%|$| |%d8<|||%��q�||$||7<|�st/��dk�stdd��D���r n/t1�fdd�t,�-|�D��}|dk�r4n||}||9}t�fdd�t,�-|�D���rMd}�qv|\}}'|�|��%|�t2d|'�f��qd|}���D]5\\}}'}|j�szt|t��r�|'tju�r�|jj�s�|��\}}|||'}nt3||'�}|�||f��qjt/|�}(t |�}t/|�|(k�s�J�|j|dd�|��D��}�dk�r�|�||j|��S�	|j|�dd ��	|dd �S�dk�r[g}g}|j
D]}
|
j�r�|�t|
�����q�|�|
��q�t.t/|��D]?}%||%\}}td!d�|�$�D���s'|j(�s'��s'|j#�s'�q|j4dd"�\})}*|)tju�rD|*tju�rDt||)�|*g||%<�qt
t�}+|D]\}}��rW�	|�}|+|�|��qL~t
t�}|+D]�}|+|�t/��dk�ry�d},n�|j(�s���r�|j��},n�g}-g}.g}/�D])}!|!j)�r�|/�|!��q�|!j5�r�|.�|!��q�|!j#�r�|.�|!��q�|-�|!��q�t/|-�dk�r�|/�r�t/|/�dk�r�|-�s�|.�6|-|/�g}-}/n:|/�rd}0|j�r�d}0n|�$�\}1}2|1j(�r�|2j(�r�d}0|0�r
d#d�|/D�}/|-�6tjgt/|/��n|-�6|/�g}/~0|-D]
}||�|��q|j|.|/�},�fd$d%��t7|,dd	�}3t/t�-|3���|,�k�rBt8|3�},||,�|��qgd&d�|��D�}4|j|4|�St9d'��))a�

    reduces expression by combining powers with similar bases and exponents.

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

    If ``deep`` is ``True`` then powsimp() will also simplify arguments of
    functions. By default ``deep`` is set to ``False``.

    If ``force`` is ``True`` then bases will be combined without checking for
    assumptions, e.g. sqrt(x)*sqrt(y) -> sqrt(x*y) which is not true
    if x and y are both negative.

    You can make powsimp() only combine bases or only combine exponents by
    changing combine='base' or combine='exp'.  By default, combine='all',
    which does both.  combine='base' will only combine::

         a   a          a                          2x      x
        x * y  =>  (x*y)   as well as things like 2   =>  4

    and combine='exp' will only combine
    ::

         a   b      (a + b)
        x * x  =>  x

    combine='exp' will strictly only combine exponents in the way that used
    to be automatic.  Also use deep=True if you need the old behavior.

    When combine='all', 'exp' is evaluated first.  Consider the first
    example below for when there could be an ambiguity relating to this.
    This is done so things like the second example can be completely
    combined.  If you want 'base' combined first, do something like
    powsimp(powsimp(expr, combine='base'), combine='exp').

    Examples
    ========

    >>> from sympy import powsimp, exp, log, symbols
    >>> from sympy.abc import x, y, z, n
    >>> powsimp(x**y*x**z*y**z, combine='all')
    x**(y + z)*y**z
    >>> powsimp(x**y*x**z*y**z, combine='exp')
    x**(y + z)*y**z
    >>> powsimp(x**y*x**z*y**z, combine='base', force=True)
    x**y*(x*y)**z

    >>> powsimp(x**z*x**y*n**z*n**y, combine='all', force=True)
    (n*x)**(y + z)
    >>> powsimp(x**z*x**y*n**z*n**y, combine='exp')
    n**(y + z)*x**(y + z)
    >>> powsimp(x**z*x**y*n**z*n**y, combine='base', force=True)
    (n*x)**y*(n*x)**z

    >>> x, y = symbols('x y', positive=True)
    >>> powsimp(log(exp(x)*exp(y)))
    log(exp(x)*exp(y))
    >>> powsimp(log(exp(x)*exp(y)), deep=True)
    x + y

    Radicals with Mul bases will be combined if combine='exp'

    >>> from sympy import sqrt
    >>> x, y = symbols('x y')

    Two radicals are automatically joined through Mul:

    >>> a=sqrt(x*sqrt(y))
    >>> a*a**3 == a**4
    True

    But if an integer power of that radical has been
    autoexpanded then Mul does not join the resulting factors:

    >>> a**4 # auto expands to a Mul, no longer a Pow
    x**2*y
    >>> _*a # so Mul doesn't combine them
    x**2*y*sqrt(x*sqrt(y))
    >>> powsimp(_) # but powsimp will
    (x*sqrt(y))**(5/2)
    >>> powsimp(x*y*a) # but won't when doing so would violate assumptions
    x*y*sqrt(x*sqrt(y))

    r)�MatrixSymbolcs@|�d��}|�d��}|�d��}|�d��}t|||||�S)N�deep�combine�force�measure)�get�powsimp)�arg�kwargs�_deep�_combine�_force�_measure)r"r!r#r$��8/usr/lib/python3/dist-packages/sympy/simplify/powsimp.py�recursefs
zpowsimp.<locals>.recurse�c�g|]}�|��qSr-r-��.0�w�r/r-r.�
<listcomp>t�zpowsimp.<locals>.<listcomp>F)r!)rrcr1r-r-�r3�ir5r-r.r6�r7���cs��|]}|jVqdS�N)�	is_Number)r3�eir-r-r.�	<genexpr>���zpowsimp.<locals>.<genexpr>NcSsg|]
\}}|r||f�qSr-r-�r3�b�er-r-r.r6�scs�|�ddS)zLReturn Rational part of x's exponent as it appears in the bkey.
            rr0r-)�x��bkeyr-r.�ratq�szpowsimp.<locals>.ratqcs�|durS|jr|tjf|fS|jr|t|j�ft|j�fS|jdd�\}}|tjurI|jr;|t|j�f|t|j�fS||t|j�ft|j�fS||tjftjfS�|�	��S)a@Return (b**s, c.q), c.p where e -> c*s. If e is not given then
            it will be taken by using as_base_exp() on the input b.
            e.g.
                x**3/2 -> (x, 2), 3
                x**y -> (x**y, 1), 1
                x**(2*y/3) -> (x**y, 3), 2
                exp(x/2) -> (exp(a), 2), 1

            NT��rational)
�
is_Integerr�One�is_Rationalr�q�p�as_coeff_Mul�
is_integer�as_base_exp)rBrC�c�mrEr-r.rF�s

zpowsimp.<locals>.bkeycs�t�||d�\}}|sA��|�|rCt�|d|�D]'}�|�\}}|�vr-d�|<�||7<|ddkr@��|�qdSdSdS)aLDecide what to do with base, b. If its exponent is now an
            integer multiple of the Rational denominator, then remove it
            and put the factors of its base in the common_b dictionary or
            update the existing bases if necessary. If it has been zeroed
            out, simply remove the base.
            r0rN)�divmod�popr
�	make_args�append)rB�newe�rrSrC)�basesrF�common_br-r.�update�s

��zpowsimp.<locals>.update)�keyT)r]�reversecss�|]	}|ddkVqdS�r0Nr-)r3�kr-r-r.r?J��cr1r-r-�r3�bi�rGr-r.r6Rr7c3s�|]	}�|�dkVqdSr_r-rbrdr-r.r?WracSsg|]	\}}t||��qSr-�rrAr-r-r.r6psr�base)r"csr;r<)�is_nonnegative)r3rDr-r-r.r?�r@rHcSsg|]}|�qSr-r-r2r-r-r.r6�scs@|jrt�fdd�|jD��S|jrt�fdd�|jD��SdS)Ncr1r-r-�r3�ai��_termsr-r.r6�r7z+powsimp.<locals>._terms.<locals>.<listcomp>cr1r-r-)r3�mirjr-r.r6�r7r0)�is_Add�sum�args�is_Mulr�rCrjr-r.rk�s
zpowsimp.<locals>._termscSs$g|]\}}|D]}t||��qqSr-re)r3rBrCr>r-r-r.r6�s$z.combine must be one of ('all', 'exp', 'base').r<):�"sympy.matrices.expressions.matexprr r�
isinstancer�is_Atomrrmrp�_yro�func�is_Powr�listrrKrL�_denest_pow�is_commutativerQrrWrr	r�iter�itemsr�NegativeOner�abs�dict�set�is_positive�is_polar�as_numer_denomrU�add�	is_SymbolrP�is_negative�sortrr
rV�range�len�minrrrrOrg�extendrr
�
ValueError)5�exprr!r"r#r$r �c_powers�nc_part�newexpr�coeff�termrBrC�b1�e1�b2�e2rS�be�skip�bpos�binv�_nr\�donerf�exponent�last�qlcm�bstart�qstart�bb�eerc�bib�bie�min1r9�ratrM�check�exp_c�exp_t�c_exp�new_base�unk�nonneg�neg�isratrN�d�	xnew_base�c_partr-)
rkrZrFr"r[r!r#r$rGr/r.r&s�U�

��"






�&
�

�

 �
�4"


�

.�
�(

r&c
s�ddlm}|rJ�fdd��g}|�tt�D]}t|jttf�r2�|j�\}}|dur2|�||f�q|r:|�	|�}||�\}}t
|d|d��|�S|r]t|�\}}t
t
t
|dd��|�Stt|��}	|	�ttd	d
�d��S)a�

    Collect exponents on powers as assumptions allow.

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

    Given ``(bb**be)**e``, this can be simplified as follows:
        * if ``bb`` is positive, or
        * ``e`` is an integer, or
        * ``|be| < 1`` then this simplifies to ``bb**(be*e)``

    Given a product of powers raised to a power, ``(bb1**be1 *
    bb2**be2...)**e``, simplification can be done as follows:

    - if e is positive, the gcd of all bei can be joined with e;
    - all non-negative bb can be separated from those that are negative
      and their gcd can be joined with e; autosimplification already
      handles this separation.
    - integer factors from powers that have integers in the denominator
      of the exponent can be removed from any term and the gcd of such
      integers can be joined with e

    Setting ``force`` to ``True`` will make symbols that are not explicitly
    negative behave as though they are positive, resulting in more
    denesting.

    Setting ``polar`` to ``True`` will do simplifications on the Riemann surface of
    the logarithm, also resulting in more denestings.

    When there are sums of logs in exp() then a product of powers may be
    obtained e.g. ``exp(3*(log(a) + 2*log(b)))`` - > ``a**3*b**6``.

    Examples
    ========

    >>> from sympy.abc import a, b, x, y, z
    >>> from sympy import Symbol, exp, log, sqrt, symbols, powdenest

    >>> powdenest((x**(2*a/3))**(3*x))
    (x**(2*a/3))**(3*x)
    >>> powdenest(exp(3*x*log(2)))
    2**(3*x)

    Assumptions may prevent expansion:

    >>> powdenest(sqrt(x**2))
    sqrt(x**2)

    >>> p = symbols('p', positive=True)
    >>> powdenest(sqrt(p**2))
    p

    No other expansion is done.

    >>> i, j = symbols('i,j', integer=True)
    >>> powdenest((x**x)**(i + j)) # -X-> (x**x)**i*(x**x)**j
    x**(x*(i + j))

    But exp() will be denested by moving all non-log terms outside of
    the function; this may result in the collapsing of the exp to a power
    with a different base:

    >>> powdenest(exp(3*y*log(x)))
    x**(3*y)
    >>> powdenest(exp(y*(log(a) + log(b))))
    (a*b)**y
    >>> powdenest(exp(3*(log(a) + log(b))))
    a**3*b**3

    If assumptions allow, symbols can also be moved to the outermost exponent:

    >>> i = Symbol('i', integer=True)
    >>> powdenest(((x**(2*i))**(3*y))**x)
    ((x**(2*i))**(3*y))**x
    >>> powdenest(((x**(2*i))**(3*y))**x, force=True)
    x**(6*i*x*y)

    >>> powdenest(((x**(2*a/3))**(3*y/i))**x)
    ((x**(2*a/3))**(3*y/i))**x
    >>> powdenest((x**(2*i)*y**(4*i))**z, force=True)
    (x*y**2)**(2*i*z)

    >>> n = Symbol('n', negative=True)

    >>> powdenest((x**i)**y, force=True)
    x**(i*y)
    >>> powdenest((n**i)**x, force=True)
    (n**i)**x

    r)�posifycs4t|ttf�s|jt||dd�fS�|j|j|�S)NF)�evaluate)rsrrr�rf)rBrC��_denestr-r.r�Eszpowdenest.<locals>._denestF)r#�polarT)�exponents_onlycSs|jpt|t�Sr<)rwrsr)rSr-r-r.�<lambda>Zszpowdenest.<locals>.<lambda>)�filter)�sympy.simplify.simplifyr��atomsrrrsrfrorW�subs�	powdenest�xreplacerrr&rrry)
�eqr#r�r��repsrN�ok�dp�rep�newr-r�r.r��s*[�
�r��ycs,ddlm}|��\}�|jst|jt�r*�dkr*|���}|dur*|}|��\}�|tj	urb�j
rbg}g}�jD]}tdd�t
�|�D��rM|�|�q9|�|�q9|t|��}tt|�t|��S|��\}}|tjur}|j
s}|jrx|jdks}|js}|Sgg}	}
t�|�D]}|jr�|	�|���q�|
�|�q�t|	�dkr�|	ddj
s�t|	dd|	dd��tt|
���S|	r�t�fdd�|	D��tt|
���S|jr�tt|��}|j
r�|j\}
}�|
9�|jd}t|��S|j
�rtd	d�t�|�D���r|Sd
d�}tt|��}|j�r6|j}t||���dk�r6���\}}t||t
�fdd�|D���}t|t��s@|j
�sl|jdj�sPt|jdt��rjt |jd�}t!|j�dkd
k�rjt|j"|j��S|Sg}g}|jD]}|j�r�|�|��qs|�|��qstt|t|����t|��S)zr
    Denest powers.

    This is a helper function for powdenest that performs the actual
    transformation.
    r)�
logcombiner0Ncss�|]}t|t�VqdSr<)rsrrhr-r-r.r?ts�z_denest_pow.<locals>.<genexpr>cs g|]\}}t||���qSr-)r�)r3r�r�rqr-r.r6�s z_denest_pow.<locals>.<listcomp>csr;r<)rt)r3�sr-r-r.r?�r@cSsfdd�||fD�\}}t|d|d���d}t|djdd�d|djdd�d@�}t||�S)NcSsg|]}|���qSr-)rOr8r-r-r.r6�r7z/_denest_pow.<locals>.nc_gcd.<locals>.<listcomp>rr0T)�cset)rr�r
�args_cncr)�aar��arBrR�gr-r-r.�nc_gcd�s,
z_denest_pow.<locals>.nc_gcdcsg|]}|��qSr-r-)r3r�)r�r-r.r6�r7T)#r�r�rQrwrsrvr�_eval_powerr�Exp1rpro�anyr	rVrWr
rrKrLrMr�r�r�r�rJrrrmrrOrryr~rf)r�r�rBr��logs�otherr>�_r��polars�	nonpolarsr��logbrRrfr��glogbro�cg�rgr�r�r-)rCr�r.ry_s�

�
�
.�


"


  
ryN)FF)+�collectionsr�sympy.core.functionrr�
sympy.corerrrrr	r
rrr
�sympy.core.compatibilityrrr�sympy.core.numbersrr�sympy.core.mulrr�sympy.core.rulesr�sympy.functionsrrrrrr�sympy.polysrr�sympy.ntheory.factor_rr&r�ruryr-r-r-r.�<module>s", 
[u
Youez - 2016 - github.com/yon3zu
LinuXploit