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 :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

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

�8Vas��@s�ddlmZddlmZddlmZmZmZmZm	Z	m
Z
mZmZm
Z
mZmZmZmZmZddlmZddlmZmZddlmZmZddlmZmZddlmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'dd	l(m)Z)dd
l*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2dd
l3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:ddl;m<Z<ddl=m>Z>gdddfdd�Z?e+e)fZ@dd�ZAdd�ZBdd�dd�ZCdd �ZDd!aEd"d#�ZFd$d%�ZGd&d'�ZHd(d'�ZId)d'�ZJd*d+�ZKd9d,d-�ZLed9d.d/��ZMdd0�d1d2�ZNd3d4�ZOd5d6�ZPd:d7d8�ZQd!S);�)�defaultdict)�reduce)�sympify�Basic�S�Expr�
expand_mul�factor_terms�Mul�Dummy�igcd�
FunctionClass�Add�symbols�Wild�expand)�cacheit)�iterable�
SYMPY_INTS)�	count_ops�_mexpand)�I�Integer)	�sin�cos�exp�cosh�tanh�sinh�tan�cot�coth)�HyperbolicFunction)�TrigonometricFunction)�Poly�factor�cancel�parallel_poly_from_expr)�ZZ)�PolificationFailed)�groebner)�cse)�identity)�greedy)�debugF�grlexc
sPdd��dd�����fdd�}td��|�tj��}�tjfg}t|���\}�zt|�g�\\}}	}
Wnty@|YSwtd|
j	�||
j	|�\}��td	|�td
�dt
���td�dt
����sk|St|��td
��tdt
��dt
���ddlm�
��r|	jt���|	j	���rt|��d�j��}g}|��D]m\}
}tt|�g�dj	��d}|r�d}|D]!}t|�}��|j	�s�|jt|j	�����s�d}��|��j	�q�|s��fdd��D�}�fdd��jD�}|�tdd�t�|
�D���
|�|�|�	t|d��|��q�t|�S�
|t
������	t|d��|�S)a

    Simplify trigonometric expressions using a groebner basis algorithm.

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

    This routine takes a fraction involving trigonometric or hyperbolic
    expressions, and tries to simplify it. The primary metric is the
    total degree. Some attempts are made to choose the simplest possible
    expression of the minimal degree, but this is non-rigorous, and also
    very slow (see the ``quick=True`` option).

    If ``polynomial`` is set to True, instead of simplifying numerator and
    denominator together, this function just brings numerator and denominator
    into a canonical form. This is much faster, but has potentially worse
    results. However, if the input is a polynomial, then the result is
    guaranteed to be an equivalent polynomial of minimal degree.

    The most important option is hints. Its entries can be any of the
    following:

    - a natural number
    - a function
    - an iterable of the form (func, var1, var2, ...)
    - anything else, interpreted as a generator

    A number is used to indicate that the search space should be increased.
    A function is used to indicate that said function is likely to occur in a
    simplified expression.
    An iterable is used indicate that func(var1 + var2 + ...) is likely to
    occur in a simplified .
    An additional generator also indicates that it is likely to occur.
    (See examples below).

    This routine carries out various computationally intensive algorithms.
    The option ``quick=True`` can be used to suppress one particularly slow
    step (at the expense of potentially more complicated results, but never at
    the expense of increased total degree).

    Examples
    ========

    >>> from sympy.abc import x, y
    >>> from sympy import sin, tan, cos, sinh, cosh, tanh
    >>> from sympy.simplify.trigsimp import trigsimp_groebner

    Suppose you want to simplify ``sin(x)*cos(x)``. Naively, nothing happens:

    >>> ex = sin(x)*cos(x)
    >>> trigsimp_groebner(ex)
    sin(x)*cos(x)

    This is because ``trigsimp_groebner`` only looks for a simplification
    involving just ``sin(x)`` and ``cos(x)``. You can tell it to also try
    ``2*x`` by passing ``hints=[2]``:

    >>> trigsimp_groebner(ex, hints=[2])
    sin(2*x)/2
    >>> trigsimp_groebner(sin(x)**2 - cos(x)**2, hints=[2])
    -cos(2*x)

    Increasing the search space this way can quickly become expensive. A much
    faster way is to give a specific expression that is likely to occur:

    >>> trigsimp_groebner(ex, hints=[sin(2*x)])
    sin(2*x)/2

    Hyperbolic expressions are similarly supported:

    >>> trigsimp_groebner(sinh(2*x)/sinh(x))
    2*cosh(x)

    Note how no hints had to be passed, since the expression already involved
    ``2*x``.

    The tangent function is also supported. You can either pass ``tan`` in the
    hints, to indicate that tan should be tried whenever cosine or sine are,
    or you can pass a specific generator:

    >>> trigsimp_groebner(sin(x)/cos(x), hints=[tan])
    tan(x)
    >>> trigsimp_groebner(sinh(x)/cosh(x), hints=[tanh(x)])
    tanh(x)

    Finally, you can use the iterable form to suggest that angle sum formulae
    should be tried:

    >>> ex = (tan(x) + tan(y))/(1 - tan(x)*tan(y))
    >>> trigsimp_groebner(ex, hints=[(tan, x, y)])
    tan(x + y)
    c
s�d}ggg}}}|D]P�t�ttf�r�}qt�t�r#|���qt��rW|��d�dd�f�|�t�fdd��dd�D��dt�dd���g�dj	�q|���q||||fS)z-Split hints into (n, funcs, iterables, gens).�rNcsg|]}�d|��qS�r���.0�x��er2�9/usr/lib/python3/dist-packages/sympy/simplify/trigsimp.py�
<listcomp>��z:trigsimp_groebner.<locals>.parse_hints.<locals>.<listcomp>)
�
isinstancerrr
�appendr�extendr'r�gens)�hints�n�funcs�	iterablesr>r2r6r8�parse_hints�s$
2���z&trigsimp_groebner.<locals>.parse_hintscSsg}td�}|D]x\}}tttt|�dt|�ddgtttt|�dt|�ddgfD]O\}}}}	|dkrF|||fvrF|�|	�q0||kr`|�|||�|||�|||��q0|||fvr|||�jdd��	||�}
|�|||�|
�q0qt
t|��S)av
        Build generators for our ideal. ``Terms`` is an iterable with elements of
        the form (fn, coeff), indicating that we have a generator fn(coeff*x).

        If any of the terms is trigonometric, sin(x) and cos(x) are guaranteed
        to appear in terms. Similarly for hyperbolic functions. For tan(n*x),
        sin(n*x) and cos(n*x) are guaranteed.
        �y�r0T��trig)rrrrrrrr<r�subs�list�set)r5�termsrrD�fn�coeff�c�s�t�rel�cnr2r2r8�build_ideal�s 	""�,��
z&trigsimp_groebner.<locals>.build_idealcsd�|�\}}}}td|d|d|d|�t|�}|�|�tt|��}tt|��}tt|��}tttttt	h��fdd�|D�}�fdd�|D�}g}i}	|D]\\}
}}|	�
|g��|
|f�qOg}
|	��D]�\}}dd�|D�}d	d�|D�}t
t|���fd
d�t||�D�}t||��tttgttt	gfD]\}}}t�fdd�|||fD��r���|���|�q��D]}td
|d
�D]	}|�||f�q�q�g}|D]M\}}|tkr�|�t|f�|�t|f�|ttfvr�t�vr�|�t|f�|t	k�r|�t|f�|�t|f�|ttfv�rt	�v�r|�t	|f�q�|�|��t|����|�}|
�|�|��fdd�|D��qg|D]P\}}|tk�rZ|�t|ft|fg��qD|t	k�rl|�t|ft|fg��qDtdt|�td�}|t|��jdd��tt||���}|
�|t|��|��qD�|v�r�|
��dd
�|���|���|
||fS)z�
        Analyse the generators ``gens``, using the hints ``hints``.

        The meaning of ``hints`` is described in the main docstring.
        Return a new list of generators, and also the ideal we should
        work with.
        zn=%szfuncs:z
iterables:z
extragens:cs*g|]}|j�vr|jd��|jf�qSr1)�func�args�as_coeff_mul�r4�g��allfuncsr2r8r9s
�z;trigsimp_groebner.<locals>.analyse_gens.<locals>.<listcomp>csg|]	}|j�vr|�qSr2)rTrWrYr2r8r9scS�g|]}|d�qS)r0r2r3r2r2r8r9,�cSr[r1r2r3r2r2r8r9-r\csg|]
\}}||�f�qSr2r2�r4rL�v)�gcdr2r8r9/�c3s�|]}|�vVqdS�Nr2r3)�fsr2r8�	<genexpr>2��z:trigsimp_groebner.<locals>.analyse_gens.<locals>.<genexpr>r0csh|]
\}}||���qSr2r2r]�r5r2r8�	<setcomp>Hr`z:trigsimp_groebner.<locals>.analyse_gens.<locals>.<setcomp>zd:%i��clsTrFrE)r.rIr=rJrrrrrr�
setdefaultr<�itemsrr�zip�any�add�ranger
r�lenrrrrH�remove)r>r?r@rArB�	extragens�	trigterms�freegens�newgens�trigdictrM�varrL�res�key�val�fnsrKrNrOrP�k�extrar^�rrU�dummys�expr)rS�myIrC)rZrbr_r5r8�analyse_gens�s~	�



��
�




$



z'trigsimp_groebner.<locals>.analyse_gensrz
initial gens:zideal:z	new gens:z -- lenz
free gens:)�orderr>�domainzgroebner basis:r)�ratsimpmodprime)r>r0TFcsg|]}|�vr|�qSr2r2r3��ourgensr2r8r9�r:z%trigsimp_groebner.<locals>.<listcomp>cs&g|]}|j��|j��r|���qSr2)�
has_only_gens�intersectionr>�as_exprrWr�r2r8r9�s�cSsg|]\}}||�qSr2r2)r4�a�br2r2r8r9�r:)r�r>�quickr��
polynomial)rrHr�
ImaginaryUnitr&�as_numer_denomr'r)r.r>ror*r(rI�sympy.simplify.ratsimpr�r�rJr�r$�ejectrK�
issuperset�
difference�update�exclude�polysr<r
rkr)rr?r�r�r�r�rH�num�pnum�pdenom�opt�idealrw�monomrM�changed�p�realgens�ourGr2)�GrS�denomrsr>r�r�r�rCr�r�r8�trigsimp_groebnersp4g�
���	
��	��r�cs�ddlm�t|�}t|dd�}|dur|di���S��dd�}|s6��dd���dd���d	d
�}nd}dd����fd
d�dd���fdd��fdd��fdd�d�|}||�S)a,
    reduces expression by using known trig identities

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

    method:
    - Determine the method to use. Valid choices are 'matching' (default),
    'groebner', 'combined', and 'fu'. If 'matching', simplify the
    expression recursively by targeting common patterns. If 'groebner', apply
    an experimental groebner basis algorithm. In this case further options
    are forwarded to ``trigsimp_groebner``, please refer to its docstring.
    If 'combined', first run the groebner basis algorithm with small
    default parameters, then run the 'matching' algorithm. 'fu' runs the
    collection of trigonometric transformations described by Fu, et al.
    (see the `fu` docstring).


    Examples
    ========

    >>> from sympy import trigsimp, sin, cos, log
    >>> from sympy.abc import x
    >>> e = 2*sin(x)**2 + 2*cos(x)**2
    >>> trigsimp(e)
    2

    Simplification occurs wherever trigonometric functions are located.

    >>> trigsimp(log(e))
    log(2)

    Using `method="groebner"` (or `"combined"`) might lead to greater
    simplification.

    The old trigsimp routine can be accessed as with method 'old'.

    >>> from sympy import coth, tanh
    >>> t = 3*tanh(x)**7 - 2/coth(x)**7
    >>> trigsimp(t, method='old') == t
    True
    >>> trigsimp(t)
    tanh(x)**7

    r)�fu�_eval_trigsimpN�oldF�deep�	recursive�method�matchingcs4��fdd���|�}t|t�s|St|fi���S)Nc�F|jr|S�fdd�|jD�}|js|jr�fdd�|D�}|j|�S)Nc�g|]}�|��qSr2r2r3��traverser2r8r9�r\zDtrigsimp.<locals>.groebnersimp.<locals>.traverse.<locals>.<listcomp>c�g|]
}t|fi����qSr2�r�r3��optsr2r8r9�r`��is_AtomrU�is_Function�is_PowrT�r7rU�r�r�r2r8r���
z0trigsimp.<locals>.groebnersimp.<locals>.traverse)r;rr�)�exr��newr2r�r8�groebnersimp�s

ztrigsimp.<locals>.groebnersimpc��|fi���Srar2re)r�r�r2r8�<lambda>��ztrigsimp.<locals>.<lambda>cSst|�Sra)�futrigrer2r2r8r��scr�rar2re�r�r�r2r8r��r�cst�|ddtgd��S�NTrE)r�r?)r�rre�r�r2r8r��s�cst|fi���Sra)�trigsimp_oldrer�r2r8r��r�)r�r�r*�combinedr�r2)�sympy.simplify.fur�r�getattr�pop)rr�r�r�r��trigsimpfuncr2)r�r�r�r8�trigsimp�s*.

��	r�cs�ddlm}m}ddlm}dd�}|||�}�fdd��||��}|�t�r3||�\}��||��}|�t�r<||�}|�t�rF|�t�rH|}|S)a#
    Simplifies exponential / trigonometric / hyperbolic functions.

    Examples
    ========

    >>> from sympy import exptrigsimp, exp, cosh, sinh
    >>> from sympy.abc import z

    >>> exptrigsimp(exp(z) + exp(-z))
    2*cosh(z)
    >>> exptrigsimp(cosh(z) - sinh(z))
    exp(-z)
    r)�
hyper_as_trig�TR2i��	bottom_upcSs>|g}|jt�r|�|�t��|�|�t��t|dti�S)Nrx)�has�_trigsr<�rewriterr�minr)r7�choicesr2r2r8�exp_trigs

zexptrigsimp.<locals>.exp_trigc
s�|js|S|��\}}t|�dkr�t|��t|�S|��}|���tjf�fdd�	�|tj}|D]�}|j	r�t|j
�dkr�|j
d}�|j
d|�\}}|sRq3||}	�||	8<|||	dkr��tj|8<d}|dkr��d|t|d�|	7<q3�d|t|d�|	7<q3�d|tj||	krԈd|tj|=|dkrĈ|t
|d�|	7<q3�|t
|d�|	7<q3�d|tj||	7<�||	7<q3t�fdd��D��S)	Nr0csZ|tjur
|tjfSt|t�s|jr|jtjkr||jfS|tjur+�|tjd�SdS)N)�sign)NN)r�Exp1�Oner;rr��base)rr�)�signlogr2r8r�)s



z'exptrigsimp.<locals>.f.<locals>.signlogrEr���csg|]}|�|�qSr2r2)r4r{)�newdr2r8r9Pr:z*exptrigsimp.<locals>.f.<locals>.<listcomp>)�is_Mul�args_cncror
�as_powers_dict�copyrr�r��is_AddrUrrr)
�rv�commutative_part�noncommutative_part�rvd�eer{rNr�r5�m��f)r�r�r8r�s@


""  �zexptrigsimp.<locals>.f)	r�r�r��sympy.simplify.simplifyr�r�r"r#r)rr�r�r�r��newexprr7r2r�r8�exptrigsimps

4

r�T)�firstcs�|}|r�|jt�s|St�jdd�|jt�D��}t|�dkr�ddlm}||�}|jr4||dd�p3|}t	|t
�rcd}|��D] \}}|}	t|�}d�d	<t
|fi���}
|
|kr[|	}
||
9}q?|}n&|jr�|D]}|�|�\}}
|r�d�d	<|t
|
fi���}|js�nqh|}��d
d�}��dd�}��dd
�}dd��dd���fdd��fdd�d�|}|r�t|�\}}||d|�}t|�D]}|�|d|d�}|||�}q�|}n|||�}��dd�r�t|�}||kr�td|�|S)aC
    Reduces expression by using known trig identities.

    Notes
    =====

    deep:
    - Apply trigsimp inside all objects with arguments

    recursive:
    - Use common subexpression elimination (cse()) and apply
    trigsimp recursively (this is quite expensive if the
    expression is large)

    method:
    - Determine the method to use. Valid choices are 'matching' (default),
    'groebner', 'combined', 'fu' and 'futrig'. If 'matching', simplify the
    expression recursively by pattern matching. If 'groebner', apply an
    experimental groebner basis algorithm. In this case further options
    are forwarded to ``trigsimp_groebner``, please refer to its docstring.
    If 'combined', first run the groebner basis algorithm with small
    default parameters, then run the 'matching' algorithm. 'fu' runs the
    collection of trigonometric transformations described by Fu, et al.
    (see the `fu` docstring) while `futrig` runs a subset of Fu-transforms
    that mimic the behavior of `trigsimp`.

    compare:
    - show input and output from `trigsimp` and `futrig` when different,
    but returns the `trigsimp` value.

    Examples
    ========

    >>> from sympy import trigsimp, sin, cos, log, cot
    >>> from sympy.abc import x
    >>> e = 2*sin(x)**2 + 2*cos(x)**2
    >>> trigsimp(e, old=True)
    2
    >>> trigsimp(log(e), old=True)
    log(2*sin(x)**2 + 2*cos(x)**2)
    >>> trigsimp(log(e), deep=True, old=True)
    log(2)

    Using `method="groebner"` (or `"combined"`) can sometimes lead to a lot
    more simplification:

    >>> e = (-sin(x) + 1)/cos(x) + cos(x)/(-sin(x) + 1)
    >>> trigsimp(e, old=True)
    (1 - sin(x))/cos(x) + cos(x)/(1 - sin(x))
    >>> trigsimp(e, method="groebner", old=True)
    2/cos(x)

    >>> trigsimp(1/cot(x)**2, compare=True, old=True)
          futrig: tan(x)**2
    cot(x)**(-2)

    cSsg|]}|j�qSr2)�free_symbols)r4rPr2r2r8r9��z trigsimp_old.<locals>.<listcomp>r0r)�separatevarsT)�dictFr�r�r�r�r�cs*��fdd��|r
�|�}t|fi���S)Ncr�)Ncr�r2r2r3r�r2r8r9�r\zHtrigsimp_old.<locals>.groebnersimp.<locals>.traverse.<locals>.<listcomp>cr�r2r�r3r�r2r8r9�r`r�r�r�r2r8r��r�z4trigsimp_old.<locals>.groebnersimp.<locals>.traverser�)r�r�r�r2r�r8r��sz"trigsimp_old.<locals>.groebnersimpcSs
t||�Sra��	_trigsimp�r5�dr2r2r8r���
ztrigsimp_old.<locals>.<lambda>cs�||fi���Srar2r�r�r2r8r��r�cst�||ddtgd�|�Sr�)r�rr�r�r2r8r��s

��)r�r*r��comparez	futrig:)r�r�rJ�union�atomsror�r�r�r;r�rjrr�r��as_independentr�r+�reversedrH�getr��print)rr�r�r��trigsymsr�r�r{r^�was�vnewrOr}r7r�r�r�r��wrX�sub�resultr�r2r�r8r�asl:


�

��

r�cCs4|j|jko|�t�r|�t�p|�t�o|�t�S)z�Helper to tell whether ``a`` and ``b`` have the same sorts
    of symbols in them -- no need to test hyperbolic patterns against
    expressions that have no hyperbolics in them.)rTr�r#r")r�r�r2r2r8�_dotrig�s�rNcCs|	tdtd�\}}}tddd�}|t|�|t|�||t|�|t|�t|�f|t|�|t|�||t|�|t|�t|�f|t|�|t|�||t|�|t|�t|�f|t|�|t|�||t|�|t|�t|�f|t|�|t|�||t|�|t|�t|�f|t|�|t|�||t|�t|�f|t|�d|t|�d||t|�d|t|�dt|�df|t|�d|t|�d||t|�d|t|�dt|�df|t|�|t|�||t|�|t	j
t	j
f|t|�|t|�||t|�|t	j
t	j
f|t|�|t|�||t|�|t	j
t	j
f|t|�|t|�||t|�|t	j
t	j
f|t|�|t|�||t|�|t	j
t	j
f|t|�|t|�||t	j
t	j
f|t|�t|�dt|�t|�t||�|t	j
t	j
ff}|t|�t|�|t|�t|�|t||�||f|t|�t|�|t|�t|�|t||�||f|t|�t|�|t|�t|�|t||�||f|t|�t|�|t|�t|�|t||�||f|t|�t|�|t|�t|�|t||�||f|t|�t|�|t|�t|�|t||�||ff}|t|�d||t|�df|t|�d|dt|�d|f|t|�d|dt|�d|f|t||�|t|�t|�t|�t|�f|t||�|t|�t|�t|�t|�f|t||�|t|�t|�dt|�t|�f|t|�d|t|�d|f|t|�d||dt|�df|t|�d||dt|�df|t||�|t|�t|�t|�t|�f|t||�|t|�t|�t|�t|�f|t||�|t|�t|�dt|�t|�ff}||t|�d||t|�d|tf||dt|�d||t|�d|tf||dt|�d||t|�d|tf||t|�d||t|�d|tf||dt|�d||t|�d|tf||dt|�d||t|�d|tf||||t|�d|||t|�d|tf||||dt|�d|||t|�d|tf||||dt|�d|||t|�d|tf||||t|�d|||t|�d|tf||||dt|�d|||t|�d|tf||||dt|�d|||t|�d|tff}||||||||fatS)Nza b crgr�F)�commutativer0rE)
rrrrrr rrrrr�r!�_trigpat)r�r�rNr��matchers_division�matchers_add�matchers_identity�	artifactsr2r2r8�	_trigpats�sz66666*"(�"(�22222&&��>>>>>>�"&&226"&&226�,22.008>>:<<��r
cCsftt�}tt�}g}|jD]?}	|	js|	j||fvrG|	��\}
}|
js%|jrG|
j|kr6||
jd|7<q
|
j|krG||
jd|7<q
|�|	�q
t	|�t	|�@}d}
|r�|�
�}|�
|�}|�
|�}|||�kr{|�||�||��d}
n|||<|||<|sY|
s�|S|r�|��\}}|�||�|�|s�|r�|��\}}|�||�|�|s�t|�S)z�Helper for _match_div_rewrite.

    Replace f(b_)**c_*g(b_)**(rexp(c_)) with h(b)**rexph(c) if f(b_)
    and g(b_) are both positive or if c_ is an integer.
    rFT)
r�intrUr�rT�as_base_exp�is_positive�
is_integerr<rJr��popitemr
)rr�rX�rexp�h�rexph�fargs�gargsrUr5r�r7�common�hitrx�fe�ger2r2r8�_replace_mul_fpowxgpowGsJ




�
��rcCs|Srar2rer2r2r8r�ssr�cCs|Srar2rer2r2r8r�t�cCstjSra)rr�rer2r2r8r�urcCsl|dkrt|ttttt�}|S|dkrt|ttttt�}|S|dkr-t|ttttt�}|S|dkr<t|ttttt�}|S|dkrKt|ttttt�}|S|dkrZt|ttttt�}|S|dkrit|tt	tt
t�}|S|dkrxt|t
t	ttt�}|S|d	kr�t|tttt	t�}|S|d
kr�t|t
ttt	t�}|S|dkr�t|tt	ttt�}|S|dkr�t|tt
ttt�}|Sd
S)zhelper for __trigsimprr0rE�����	�
���
N)rrr�_midnr�_idnr �_onerrrr!)r�ir2r2r8�_match_div_rewritewsz�&��#�� ������������
��
�����r(cCs|jt�r
t||�S|Sra)r�r��
__trigsimp)rr�r2r2r8r��s

r�csBddlm}tdur
t�t\��}}}}}}|jr�|js1|��\}	}
tt�	|	���t�	|
�}nct
|�D]^\}\}}
}}t||�sCq5t||�}|durU||krT|}n@q5|�
|���r���|d�r��|jsy|���}|jspq5|���}|jsyq5t��fdd����tt�D��r�q5|
���}nq5|j�r�g}|jD]<}|js�|��\}	}
t�	|
�}
t�	|	�}ntj}
t|��}|D]\}}|�
|���dur�|���}nq�|�||
�q�||jkr�t|�}t|t|�td�}|j�r7|D]D\}}t||�s�q�||�}|�t��r6|�
|���du�s.��v�r.��v�r.t���fdd��|�tt�D���r/q�|���}nq�|D]~\}}}t||��sF�q9t d|gd	�}|��|�}|��|�}|�
|�}d}|�r�||k�r�|}||dk�s�||||jv�s�||||dk�r�n.||v�r�||||||dk�r�n|�|�}|�
|�}|�!|tj"�|�r�||k�sh�q9n|j�s�|j#�sȈ�r�|j�r�|j$�fd
d�|jD��}z@|jt%��s�t&�|�t'�}|j(t'�d�}||k�r�t&�t)|�}||k�rt*|t)|�gtd�d}|�t'�|�s|}W|SW|St&�y Y|Sw)
zrecursive helper for trigsimpr)�TR10iNc3s"�|]}|jd��kVqdS�rN�rU�r4r)r�rwr2r8rc�s� z__trigsimp.<locals>.<genexpr>)rxc3s*�|]}|jd����fvVqdSr+r,r-)r�r�rwr2r8rc�s�
�r�)r�csg|]}t|���qSr2r�)r4r��r�r2r8r9sz__trigsimp.<locals>.<listcomp>r.)+r�r*rr
r��is_commutativer�r�r
�
_from_args�	enumeraterr(�matchr�rrHr
rlr�r#r"r�rUrr�r<rr�rrr�rri�Zeror�rTr��	TypeErrorrr�r%�sorted)rr�r*rNr�rrrr	�com�ncr'�pattern�simp�ok1�ok2r��okrU�termrr��a_tr�r�r7r��fnewr2)r�r�r�rwr8r)�s��






�
�




�


.�
�
�
,(

���


���r))�hypercKs�ddlm}ddlm}t|�}t|t�s|S|js|S|}||t�}|r7|�	t
�r7||�\}}|||t��}||krJ|jrJ|jdjrJt
|���}|S)aReturn simplified ``e`` using Fu-like transformations.
    This is not the "Fu" algorithm. This is called by default
    from ``trigsimp``. By default, hyperbolics subexpressions
    will be simplified, but this can be disabled by setting
    ``hyper=False``.

    Examples
    ========

    >>> from sympy import trigsimp, tan, sinh, tanh
    >>> from sympy.simplify.trigsimp import futrig
    >>> from sympy.abc import x
    >>> trigsimp(1/tan(x)**2)
    tan(x)**(-2)

    >>> futrig(sinh(x)/tanh(x))
    cosh(x)

    r)r�r�)r�r�r�r�rr;rrU�_futrigr�r"r��is_Rationalr
�as_coeff_Mul)r7r@�kwargsr�r�r�r�r2r2r8r�.s

r�c"s�ddlm}m�m}m�m}m�m}m}m	�m
�m�m}m
�m}m}m}	m}
m�m�ddlm�	|�t�s7|S|jrB|�t�\}}nd}��	fdd�}dd��
t||��
fdd��t�
fd	d�g��
fd
d�|
�|||	��
fdd�|
t�
fdd�g||t|gt��fd
d�g��
fdd���
fdd�g��
fdd���
fdd�g|t�gt��
fdd�g|��t��
fdd�gfg}
t|
|d�|�}|dur�||}|S)zHelper for futrig.r)�TR1�TR2�TR3r��TR10�Lr*�TR8�TR6�TR15�TR16�TR111�TR5�TRmorrie�TR11�_TR11�TR14�TR22�TR12)�_nodesNcs"�|�|���|�t|j�|jfSra)rrorUr�re)rIrVr2r8r�js"z_futrig.<locals>.<lambda>cSs
|�t�Sra)r�r#rer2r2r8r�kr�c�tt|��Sra��_eapplyr%re��trigsr2r8r�r�crWra�rYrrerZr2r8r�tr\cstdd�|��S)NcSst|���Sra)r%�normal)r'r2r2r8r�vr\z+_futrig.<locals>.<lambda>.<locals>.<lambda>�rYrerZr2r8r�vr�crWrarXrerZr2r8r�{r\crWrar]rerZr2r8r�}r\cs��|��Srar2re)rFr�r2r8r��r\c�tt�|���Sra�rYrre)rOr[r2r8r��r�cr`rarare)rLr[r2r8r���
�cr`rarare)rKr[r2r8r��r�cr`rarare)rMr[r2r8r��rbcr`rarare)rTr[r2r8r��rbcr`ra)rYr	re)rUr[r2r8r��rb)�	objective)r�rErFrGr�rHrIr*rJrKrLrMrNrOrPrQrRrSrTrU�sympy.core.compatibilityrVr�r#r�r�r,r-)r7rErGrHr*rJrNrPrQrRrSrM�Lops�treer2)rIrUrLrMrFrTr�rOrKrVr[r8rAZs\T



����%rAcCsBddlm}t||�rt|j�St|t�sdStdd�|jD��S)zD_eapply helper to tell whether ``e`` and all its args
    are Exprs.r)�
DerivativeFcss�|]}t|�VqdSra)�_is_Expr)r4r'r2r2r8rc�rdz_is_Expr.<locals>.<genexpr>)�sympyrgr;rhrr�allrU)r7rgr2r2r8rh�s


rhcs@t|t�s|St|�s|js�|�S|j��fdd�|jD��S)zdApply ``func`` to ``e`` if all args are Exprs else only
    apply it to those args that *are* Exprs.cs*g|]}�dus�|�rt�|�n|�qSrar_)r4�ei��condrTr2r8r9�s��z_eapply.<locals>.<listcomp>)r;rrhrUrT)rTr7rmr2rlr8rY�s
�rY)Fra)R�collectionsr�	functoolsr�
sympy.corerrrrrr	r
rrr
rrrr�sympy.core.cacherrdrr�sympy.core.functionrr�sympy.core.numbersrr�sympy.functionsrrrrrrrr r!�%sympy.functions.elementary.hyperbolicr"�(sympy.functions.elementary.trigonometricr#�sympy.polysr$r%r&r'�sympy.polys.domainsr(�sympy.polys.polyerrorsr)�sympy.polys.polytoolsr*�sympy.simplify.cse_mainr+�sympy.strategies.corer,�sympy.strategies.treer-�sympy.utilities.miscr.r�r�r�r�r�rrr
rr%r$r&r(r�r)r�rArhrYr2r2r2r8�<module>sZ@,
�W`		T,
,,@

Youez - 2016 - github.com/yon3zu
LinuXploit