| 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 : |
o
�8Va\T � @ s� d dl mZmZmZmZmZ d dlmZmZm Z d dl
m Z d dl m
Z
mZmZ d dlmZmZ d dlmZ dd� Zd d
� Zd d � Zd
d� Zd(dd�Zdd� ZG dd� de�Z dd� Z dd� Z d)dd �Z d d � Z d d � Z!d!d"� Z"d#d$� Z#d%d&� Z$d'S )*� )�Add�Expr�Mul�S�sympify)�_mexpand� count_ops�
expand_mul)�Dummy)�root�sign�sqrt)�Poly�PolynomialError)�default_sort_keyc C s | j o| jjot| j�tju S )z/Return True if expr is a sqrt, otherwise False.)�is_Pow�exp� is_Rational�absr �Half)�expr� r �;/usr/lib/python3/dist-packages/sympy/simplify/sqrtdenest.py�is_sqrt s r c C sV | t ju rdS | jr dS | js| jr tdd� | jD �td�S t| �r)t | j
�d S dS )a� Return the maximum depth of any square root argument of p.
>>> from sympy.functions.elementary.miscellaneous import sqrt
>>> from sympy.simplify.sqrtdenest import sqrt_depth
Neither of these square roots contains any other square roots
so the depth is 1:
>>> sqrt_depth(1 + sqrt(2)*(1 + sqrt(3)))
1
The sqrt(3) is contained within a square root so the depth is
2:
>>> sqrt_depth(1 + sqrt(2)*sqrt(1 + sqrt(3)))
2
� r c S � g | ]}t |��qS r ��
sqrt_depth��.0�xr r r �
<listcomp>& � z sqrt_depth.<locals>.<listcomp>��key) r �
ImaginaryUnit�is_Atom�is_Add�is_Mul�max�argsr r r �base��pr r r r s
r c C sX | j rdS | jr
dS t| �s| jr| jjrt| j�S | js | j r*t
dd� | j D ��S dS )a� Return True if p is comprised of only Rationals or square roots
of Rationals and algebraic operations.
Examples
========
>>> from sympy.functions.elementary.miscellaneous import sqrt
>>> from sympy.simplify.sqrtdenest import is_algebraic
>>> from sympy import cos
>>> is_algebraic(sqrt(2)*(3/(sqrt(7) + sqrt(5)*sqrt(2))))
True
>>> is_algebraic(sqrt(2)*(3/(sqrt(7) + sqrt(5)*cos(2))))
False
TFc s � � | ]}t |�V qd S �N)� is_algebraicr r r r � <genexpr>D � � z is_algebraic.<locals>.<genexpr>) r r& r r r �
is_Integerr0 r+ r' r( �allr* r, r r r r0 - s
r0 c C s� | dkr
dgg}|S | dkrddgddgddgg}|S | dkr8g d�g d�g d�g d�g d �g d
�g d �g}|S t | d �}d d
� |D �}dd
� |D �}|dg| d dg g | }|S )ag
Returns all possible subsets of the set (0, 1, ..., n-1) except the
empty set, listed in reversed lexicographical order according to binary
representation, so that the case of the fourth root is treated last.
Examples
========
>>> from sympy.simplify.sqrtdenest import _subsets
>>> _subsets(2)
[[1, 0], [0, 1], [1, 1]]
r � r � )r r r )r r r )r r r )r r r )r r r )r r r )r r r c S � g | ]}|d g �qS )r r r r r r r! ` � z _subsets.<locals>.<listcomp>c S r7 )r r r r r r r! a r8 )�_subsets)�n�a�b�a0�a1r r r r9 I s � �� � r9 r6 c C s: t t| ��} t|�D ]}t| �}| |kr| S |} q
| S )a� Denests sqrts in an expression that contain other square roots
if possible, otherwise returns the expr unchanged. This is based on the
algorithms of [1].
Examples
========
>>> from sympy.simplify.sqrtdenest import sqrtdenest
>>> from sympy import sqrt
>>> sqrtdenest(sqrt(5 + 2 * sqrt(6)))
sqrt(2) + sqrt(3)
See Also
========
sympy.solvers.solvers.unrad
References
==========
.. [1] http://researcher.watson.ibm.com/researcher/files/us-fagin/symb85.pdf
.. [2] D. J. Jeffrey and A. D. Rich, 'Symplifying Square Roots of Square Roots
by Denesting' (available at http://www.cybertester.com/data/denest.pdf)
)r r �range� _sqrtdenest0)r �max_iter�i�zr r r �
sqrtdenestf s rD c C s* ddl m} t| �} | jr| tjtjf}t |�S | jr�t| jt d�}dd� |D �}t
dd� |D ��rB|| �\}}}|||f}t |�S dd� t |�D �}t
|t d�} | d dkr]g }t |�S | \}
} } |�| �}|�| � tj}|jr�g }
g }|jD ]}t|�|
k r�|
�|� qy|�|� qyt�|
�}t�|�}g }|g}|D ]F}|d |
k r�|�|d � q�|d }||kr�|�d � q�|jr�t |j�}||v r�|�|� |�t|� � q�|�|d � q�|�|d � q�t|� }t|� }|||d
f}t |�S | �� \}}t|��rtj||d
f}t |�S g }t |�S ) a� Return [a, b, r] for p.match(a + b*sqrt(r)) where, in addition to
matching, sqrt(r) also has then maximal sqrt_depth among addends of p.
Examples
========
>>> from sympy.functions.elementary.miscellaneous import sqrt
>>> from sympy.simplify.sqrtdenest import _sqrt_match
>>> _sqrt_match(1 + sqrt(2) + sqrt(2)*sqrt(3) + 2*sqrt(1+sqrt(5)))
[1 + sqrt(2) + sqrt(6), 2, 1 + sqrt(5)]
r )� split_surdsr# c S s g | ]}|d �qS )r5 r r r r r r! � r" z _sqrt_match.<locals>.<listcomp>c s s � | ] }|j o |jV qd S r/ )r � is_positive)r �sqr r r r1 � s � z _sqrt_match.<locals>.<genexpr>c S s g | ] \}}t |�||f�qS r r )r rB r r r r r! � s r r5 )�sympy.simplify.radsimprE r � is_Numberr �Zeror' �sortedr* r r4 �list� enumerater) �pop�Oner( r �appendr �
_from_args�remover � as_coeff_Mulr )r- rE �res�pargs�sqargs�rr< r; �v�nmax�depth�_rB �bv�rvr r> �b1�x1�x1argsr r r � _sqrt_match� sn <�
.
�
�
�ra c @ s e Zd ZdS )�SqrtdenestStopIterationN)�__name__�
__module__� __qualname__r r r r rb � s rb c C sJ t | �rY| �� \}}|tju rJ|jjrFt|jjtd�}t |�dkr9t
dd� |D ��r9zt |�W S t y8 Y nw t
ttdd� |D �� ��} t| �S dd� ||fD �\}}|| S t| t�r�g }g }| jD ]}|�� \}}|�|� |�|� qet
dd� |D ��r�t
d d� |D ��r�t||�S t| t�r�| j}|r�| jd
d� |D �� S | S ) z+Returns expr after denesting its arguments.r# r5 c s s � | ]}|d j V qdS )r5 N)r3 r r r r r1 � s � z _sqrtdenest0.<locals>.<genexpr>c S r r �r@ r r r r r! � r" z _sqrtdenest0.<locals>.<listcomp>c S r r rf �r rB r r r r! � r" c s � � | ]}|j V qd S r/ )r )r �cr r r r1 � � � c s r. r/ )r )r �argr r r r1 � r2 c S r r rf )r r; r r r r! � r" )r �as_numer_denomr rO r+ r' rK r* r �lenr4 �_sqrtdenest_recrb r
r r � _sqrtdenest1�
isinstancerS rP �
_sqrt_ratcombr �func)r r: �dr* �csrk ri r; r r r r@ � s:
�
$
r@ c C s� ddl m}m}m} | jst| �S | jdk r"td�tt| j �� S || j�\}}}|t|� }||k r9||}}t |d |d �}t
|j �dkr�||�\}}} |t|� }|| k r`| |}} t |d | d �}
tt|
��} tt|| ��} || | �\}
}t | td� |
|td� �}nt t|��}t
|�dkr�t�|| }t
|j �t
| j �kr�t|�t| j�kr�t�tt|��}t
|�dkr�t�|||�\}
}|td� |
|td� }||�}t |�S )al Helper that denests the square root of three or more surds.
Explanation
===========
It returns the denested expression; if it cannot be denested it
throws SqrtdenestStopIteration
Algorithm: expr.base is in the extension Q_m = Q(sqrt(r_1),..,sqrt(r_k));
split expr.base = a + b*sqrt(r_k), where `a` and `b` are on
Q_(m-1) = Q(sqrt(r_1),..,sqrt(r_(k-1))); then a**2 - b**2*r_k is
on Q_(m-1); denest sqrt(a**2 - b**2*r_k) and so on.
See [1], section 6.
Examples
========
>>> from sympy import sqrt
>>> from sympy.simplify.sqrtdenest import _sqrtdenest_rec
>>> _sqrtdenest_rec(sqrt(-72*sqrt(2) + 158*sqrt(5) + 498))
-sqrt(10) + sqrt(2) + 9 + 9*sqrt(5)
>>> w=-6*sqrt(55)-6*sqrt(35)-2*sqrt(22)-2*sqrt(14)+2*sqrt(77)+6*sqrt(10)+65
>>> _sqrtdenest_rec(sqrt(w))
-sqrt(11) - sqrt(7) + sqrt(2) + 3*sqrt(5)
r )�radsimp�rad_rationalizerE ���r5 r )rH ru rv rE r rD r+ r
rn r rm r* ro r rb r )r ru rv rE �gr; r< �c2r> r^ �c2_1�c_1�d_1�num�denri �acrs rW r r r rn sD
" rn Tc
C s| ddl m} t| �s | S | j}|jr| S t|�}|s | S |\}}}t|d |d | �}|jrf|jrAt ||||�}|dur@|S n1t| | �} t
| �}
|
jret t|| �||| �}|dure|t |d� S n t |||�}|durr|S |rxt
| �sz| S t| ||||�} | r�| S ||||g} t|| d �g| dt| ��d }| d du r�| S |dur�t|�t| �kr�t|�t| �kr�| S |S | S )zcReturn denested expr after denesting with simpler methods or, that
failing, using the denester.r �ru r5 N� r )�sympy.simplify.simplifyru r r+ r& ra r r rF �_sqrt_numeric_denestr
r �_sqrt_symbolic_denestr0 �sqrt_biquadratic_denest� _denesterr r )
r �denesterru r; �valr< rW �d2rC �dr2�drrT �av0r r r ro B sR
�� ro c
C s t t| ||f�\} }}t|�}|sdS |\}}}|r|tddd�}zt| �t|�|d | | �|�}W n
ty= Y dS w |�� dkr~|� � \} }
} |
|7 }
t
|
d d| | �� d�r�t| t|�|
d| d �} | j rzt
t
�| �� ��} | S dS dS dS )a4 Given an expression, sqrt(a + b*sqrt(b)), return the denested
expression or None.
Explanation
===========
If r = ra + rb*sqrt(rr), try replacing sqrt(rr) in ``a`` with
(y**2 - ra)/rb, and if the result is a quadratic, ca*y**2 + cb*y + cc, and
(cb + b)**2 - 4*ca*cc is 0, then sqrt(a + b*sqrt(r)) can be rewritten as
sqrt(ca*(sqrt(r) + (cb + b)/(2*ca))**2).
Examples
========
>>> from sympy.simplify.sqrtdenest import _sqrt_symbolic_denest, sqrtdenest
>>> from sympy import sqrt, Symbol
>>> from sympy.abc import x
>>> a, b, r = 16 - 2*sqrt(29), 2, -10*sqrt(29) + 55
>>> _sqrt_symbolic_denest(a, b, r)
sqrt(11 - 2*sqrt(29)) + sqrt(5)
If the expression is numeric, it will be simplified:
>>> w = sqrt(sqrt(sqrt(3) + 1) + 1) + 1 + sqrt(2)
>>> sqrtdenest(sqrt((w**2).expand()))
1 + sqrt(2) + sqrt(1 + sqrt(1 + sqrt(3)))
Otherwise, it will only be simplified if assumptions allow:
>>> w = w.subs(sqrt(3), sqrt(x + 3))
>>> sqrtdenest(sqrt((w**2).expand()))
sqrt((sqrt(sqrt(sqrt(x + 3) + 1) + 1) + 1 + sqrt(2))**2)
Notice that the argument of the sqrt is a square. If x is made positive
then the sqrt of the square is resolved:
>>> _.subs(x, Symbol('x', positive=True))
sqrt(sqrt(sqrt(x + 3) + 1) + 1) + 1 + sqrt(2)
N�yT)�positiver5 r� r )�mapr ra r
r �subsr
r �degree�
all_coeffsr �equals� is_numberr rQ �as_content_primitive)
r; r< rW �rval�ra�rb�rrr� �newa�ca�cb�ccrC r r r r� } s. *
& � �r� c C s� t |�}| | }t|�t|�d k s|d jrJt|�t|�}}|| kr*dkr0n nd }}|t | | � |t | | � t d� d }|�� S dS )z~Helper that denest
$\sqrt{a + b \sqrt{r}}, d^2 = a^2 - b^2 r > 0$
If it cannot be denested, it returns ``None``.
r r5 rw N)r
r r r �expand) r; r< rW r� rs �s�s1�s2rT r r r r� � s ,�r� c C s( ddl m}m} |dks|dk s|rt| j�dk rdS |||fD ]}|jD ]}|d } | jr1| js5 dS q%q tt t
||����}
t|
�dkrIdS |d |
d |d |
d g\} } | | fD ]2}t t
|��}
t|
�dkrnq_||td|
��\}}|| }|
|t
|� }|dk r�| }t|� S dS )a� denest expr = sqrt(a + b*sqrt(r))
where a, b, r are linear combinations of square roots of
positive rationals on the rationals (SQRR) and r > 0, b != 0,
d2 = a**2 - b**2*r > 0
If it cannot denest it returns None.
Explanation
===========
Search for a solution A of type SQRR of the biquadratic equation
4*A**4 - 4*a*A**2 + b**2*r = 0 (1)
sqd = sqrt(a**2 - b**2*r)
Choosing the sqrt to be positive, the possible solutions are
A = sqrt(a/2 +/- sqd/2)
Since a, b, r are SQRR, then a**2 - b**2*r is a SQRR,
so if sqd can be denested, it is done by
_sqrtdenest_rec, and the result is a SQRR.
Similarly for A.
Examples of solutions (in both cases a and sqd are positive):
Example of expr with solution sqrt(a/2 + sqd/2) but not
solution sqrt(a/2 - sqd/2):
expr = sqrt(-sqrt(15) - sqrt(2)*sqrt(-sqrt(5) + 5) - sqrt(3) + 8)
a = -sqrt(15) - sqrt(3) + 8; sqd = -2*sqrt(5) - 2 + 4*sqrt(3)
Example of expr with solution sqrt(a/2 - sqd/2) but not
solution sqrt(a/2 + sqd/2):
w = 2 + r2 + r3 + (1 + r3)*sqrt(2 + r2 + 5*r3)
expr = sqrt((w**2).expand())
a = 4*sqrt(6) + 8*sqrt(2) + 47 + 28*sqrt(3)
sqd = 29 + 20*sqrt(3)
Define B = b/2*A; eq.(1) implies a = A**2 + B**2*r; then
expr**2 = a + b*sqrt(r) = (A + B*sqrt(r))**2
Examples
========
>>> from sympy import sqrt
>>> from sympy.simplify.sqrtdenest import _sqrt_match, sqrt_biquadratic_denest
>>> z = sqrt((2*sqrt(2) + 4)*sqrt(2 + sqrt(2)) + 5*sqrt(2) + 8)
>>> a, b, r = _sqrt_match(z**2)
>>> d2 = a**2 - b**2*r
>>> sqrt_biquadratic_denest(z, a, b, r, d2)
sqrt(2) + sqrt(sqrt(2) + 2) + 2
r )ru rv r5 Nr ) rH ru rv r r+ r* r3 rF r rD r
)r r; r< rW r� ru rv r r� �y2�sqdr_ �x2�A�Bn�Bd�BrC r r r r� � s2 0"
�� $ r� c s� ddl m} ||kr dS |d du rdS |d du rftdd� �D ��rftt���D ]/�tt��fdd �tt���D �� �}��d�dkrK�d
rK| }t |�}|j
rX|�f S q)t �d
�dgt�� fS d� |d dur�|dd � g}|d � |d � g}d|d< nHt t dd
d � �D ���}|D ] } | d r�� dur�� | d kr�d|d< dS q�| d � q�� du r�t �d
�dgt�� fS � fdd �|D �� g }t
|||d |�\}
��s�dS t�fdd�tt���D ��s�|d
} t | d t| d |
� ��fS t��fdd �tt���D �� }t|�} d�v �r:��d�t��d k �r:�t��d �r:| d | d< | d | d< �t�� �s�t| d |
�} | dk�r[t �d
�dgt�� fS t| �t� �d k�sr| d j�srd|d< dS tt | �dd�} t| �t� �d k�s�d|d< dS |d| �}
t| t d � | d t � � |
t d � �}|�fS t| d � �|
}|dk�r�t �d
�dgt�� fS tt� �d�t |�}}t|t d �| | d | t d �| ��fS )a� Denests a list of expressions that contain nested square roots.
Explanation
===========
Algorithm based on <http://www.almaden.ibm.com/cs/people/fagin/symb85.pdf>.
It is assumed that all of the elements of 'nested' share the same
bottom-level radicand. (This is stated in the paper, on page 177, in
the paragraph immediately preceding the algorithm.)
When evaluating all of the arguments in parallel, the bottom-level
radicand only needs to be denested once. This means that calling
_denester with x arguments results in a recursive invocation with x+1
arguments; hence _denester has polynomial complexity.
However, if the arguments were evaluated separately, each call would
result in two recursive invocations, and the algorithm would have
exponential complexity.
This is discussed in the paper in the middle paragraph of page 179.
r r� )NNr Nc s rh r/ )rI )r r: r r r r1 7 rj z _denester.<locals>.<genexpr>c � g | ]
}� | r�| �qS r r rg ��f�nestedr r r! 9 � z _denester.<locals>.<listcomp>rw r5 r6 c S r r )ra )r r r r r r! I r" c s0 g | ]}t |d d �t � |d d � �qS )r r5 r )r )r rX )�Rr r r! U s
��c 3 s � | ]}� | V qd S r/ r rg )r� r r r1 Z r2 c r� r r rg r� r r r! ^ r� F)r� r� )r� ru r4 r9 rm r r r? �countr
r rL �filterr� �anyra �indexr rI ro r )r� r� �h�max_depth_levelru r- �sqp�values�nested2rX rs �vad�sqvad�sqvad1rT r� �FRr� r )r� r� r� r r� s� �$ �
��
�� 4
� ,
0r� c
C s� ddl m} dd� }||�}|du r tdd� t| |�D �� S |\}}}| �|�}|�|� || } | | ||| | j �7 < t| |�S )a# Denest rational combinations of radicals.
Based on section 5 of [1].
Examples
========
>>> from sympy import sqrt
>>> from sympy.simplify.sqrtdenest import sqrtdenest
>>> z = sqrt(1+sqrt(3)) + sqrt(3+3*sqrt(3)) - sqrt(10+6*sqrt(3))
>>> sqrtdenest(z)
0
r r� c S s| t | �}t|d �D ]1}t|d |�D ]'}| | j}| | j}t|| �}tt|��}|t|�kr:|||f S qq
d S )Nr )rm r? r+ r rD r
)r; r: rB �jr� r� r- r� r r r �find� s
���z_sqrt_ratcomb.<locals>.findNc S s g | ]\}}|| �qS r r )r ri rk r r r r! � s z!_sqrt_ratcomb.<locals>.<listcomp>)rH ru r �ziprN r+ rq )
rt r* ru r� �indicesr� �i1�i2ry r> r r r rq ~ s
rq N)r6 )T)%�
sympy.corer r r r r �sympy.core.functionr r r �sympy.core.symbolr
�sympy.functionsr r r
� sympy.polysr r �sympy.utilitiesr r r r0 r9 rD ra �
StopIterationrb r@ rn ro r� r� r� r� rq r r r r �<module> s*
$O%
@;?J d