o
    RhS                     @  s  d Z ddlmZ ddlmZ ddlmZmZmZm	Z	m
Z
mZ ddlmZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZmZ ddlmZ ddlmZ ddlmZ ddlm Z  ddl!m"Z" ddl#m$Z$ ddl%m&Z&m'Z' ddl(m)Z) ddl*m+Z+ ddl,m-Z- ddl.m/Z/m0Z0 ddl1m2Z2 ddl3m4Z4 ddl5m6Z6 ddl7m8Z8 e4e&fddZ9e4e&fddZ:e4e&fddZ;e4d d! Z<G d"d# d#e2Z=G d$d% d%ee2eZ>d&S )'z!Sparse rational function fields.     )annotations)reduce)addmulltlegtge)Expr)Mod)Exp1)S)Symbol)CantSympifysympify)ExpBase)Domain)DomainElementFractionField)PolynomialRing)construct_domain)lexMonomialOrder)CoercionFailed)build_options)_parallel_dict_from_expr)PolyRingPolyElement)DefaultPrinting)public)is_sequence)pollutec                 C  s   t | ||}|f|j S )zFConstruct new rational function field returning (field, x1, ..., xn). 	FracFieldgenssymbolsdomainorder_field r+   T/home/air/sanwanet/backup_V2/venv/lib/python3.10/site-packages/sympy/polys/fields.pyfield   s   r-   c                 C  s   t | ||}||jfS )zHConstruct new rational function field returning (field, (x1, ..., xn)). r#   r&   r+   r+   r,   xfield$   s   
r.   c                 C  s(   t | ||}tdd |jD |j |S )zSConstruct new rational function field and inject generators into global namespace. c                 S  s   g | ]}|j qS r+   )name).0symr+   r+   r,   
<listcomp>.   s    zvfield.<locals>.<listcomp>)r$   r"   r'   r%   r&   r+   r+   r,   vfield*   s   r3   c              	   O  s   d}t | s| gd} }ttt| } t||}g }| D ]	}||  qt||\}}|jdu rEt	dd |D g }t
||d\|_}	t|j|j|j}
g }tdt|dD ]}||
t|||d   qX|rr|
|d fS |
|fS )	a  Construct a field deriving generators and domain
    from options and input expressions.

    Parameters
    ==========

    exprs   : py:class:`~.Expr` or sequence of :py:class:`~.Expr` (sympifiable)

    symbols : sequence of :py:class:`~.Symbol`/:py:class:`~.Expr`

    options : keyword arguments understood by :py:class:`~.Options`

    Examples
    ========

    >>> from sympy import exp, log, symbols, sfield

    >>> x = symbols("x")
    >>> K, f = sfield((x*log(x) + 4*x**2)*exp(1/x + log(x)/3)/x**2)
    >>> K
    Rational function field in x, exp(1/x), log(x), x**(1/3) over ZZ with lex order
    >>> f
    (4*x**2*(exp(1/x)) + x*(exp(1/x))*(log(x)))/((x**(1/3))**5)
    FTNc                 S  s   g | ]}t | qS r+   )listvalues)r0   repr+   r+   r,   r2   Y   s    zsfield.<locals>.<listcomp>)optr      )r!   r4   mapr   r   extendas_numer_denomr   r(   sumr   r$   r%   r)   rangelenappendtuple)exprsr'   optionssingler7   numdensexprrepscoeffs_r*   fracsir+   r+   r,   sfield1   s&   

 rK   c                   @  s   e Zd ZU dZded< ded< ded< ded	< d
ed< ded< efddZdd Zdd Zdd Z	dd Z
dd Zdd Zdd Zd1dd Zd1d!d"Zd#d$ Zd%d& Zd'd( ZeZd)d* Zd+d, Zd-d. Zd/d0 ZdS )2r$   z2Multivariate distributed rational function field. r   ringztuple[FracElement, ...]r%   ztuple[Expr, ...]r'   intngensr   r(   r   r)   c                 C  s   t |||}|j}|j}|j}|j}| j||||f}t| }||_t	||_
||_||_||_||_||_t||jj|_||j|_||j|_| |_t|j|jD ]\}}	t|tro|j}
t||
sot||
|	 qX|S N)r   r'   rN   r(   r)   __name__object__new___hash_tuplehash_hashrL   FracElementzeroraw_newdtypeone_gensr%   zip
isinstancer   r/   hasattrsetattr)clsr'   r(   r)   rL   rN   rS   objsymbol	generatorr/   r+   r+   r,   rR   q   s2   




zFracField.__new__c                   s   t  fdd jjD S )z(Return a list of polynomial generators. c                   s   g | ]}  |qS r+   rY   r0   genselfr+   r,   r2      s    z#FracField._gens.<locals>.<listcomp>)r@   rL   r%   rg   r+   rg   r,   r[      s   zFracField._gensc                 C     | j | j| jfS rO   )r'   r(   r)   rg   r+   r+   r,   __getnewargs__      zFracField.__getnewargs__c                 C  s   | j S rO   )rU   rg   r+   r+   r,   __hash__   s   zFracField.__hash__c                 C  s,   |  |r| j| S td| j|f )Nzexpected a %s, got %s instead)
is_elementrL   indexto_poly
ValueErrorrY   )rh   rf   r+   r+   r,   rn      s   
zFracField.indexc                 C  s2   t |to| j| j| j| jf|j|j|j|jfkS rO   )r]   r$   r'   rN   r(   r)   rh   otherr+   r+   r,   __eq__   s
   
zFracField.__eq__c                 C  
   | |k S rO   r+   rq   r+   r+   r,   __ne__      
zFracField.__ne__c                 C  s   t |to	|j| kS )zBTrue if ``element`` is an element of this field. False otherwise. )r]   rV   r-   rh   elementr+   r+   r,   rm      s   zFracField.is_elementNc                 C  s   |  ||S rO   rd   rh   numerdenomr+   r+   r,   rX         zFracField.raw_newc                 C  s*   |d u r| j j}||\}}| ||S rO   )rL   rZ   cancelrX   ry   r+   r+   r,   new   s   zFracField.newc                 C  s   | j |S rO   )r(   convertrw   r+   r+   r,   
domain_new   r|   zFracField.domain_newc                 C  s   z
|  | j|W S  ty?   | j}|js>|jr>| j}| }||}||	|}||
|}| || Y S  w rO   )r~   rL   
ground_newr   r(   is_Fieldhas_assoc_Field	get_fieldr   rz   r{   rX   )rh   rx   r(   rL   ground_fieldrz   r{   r+   r+   r,   r      s   
zFracField.ground_newc                 C  sb  t |tr6| |jkr|S t | jtr| jj|jkr| |S t | jtr2| jj |jkr2| |S t	dt |t
r}| \}}t | jtrU|j| jjkrU| j|}nt | jtrk|j| jj krk| j|}n|| j}| j|}| ||S t |trt|dkrtt| jj|\}}| ||S t |trt	dt |tr| |S | |S )N
conversionr8   parsing)r]   rV   r-   r(   r   r   r   rL   to_fieldNotImplementedErrorr   clear_denomsto_ringset_ringrX   r@   r>   r4   r9   ring_newr~   strr
   	from_expr)rh   rx   r{   rz   r+   r+   r,   	field_new   s:   








zFracField.field_newc                   s6   | j tdd  D  fdd  |S )Nc                 s  s,    | ]}|j st|tr|| fV  qd S rO   )is_Powr]   r   as_base_expre   r+   r+   r,   	<genexpr>   s    z*FracField._rebuild_expr.<locals>.<genexpr>c                   s2   | }|d ur|S | jrtttt | jS | jr'tttt | jS | j	s1t
| ttfri|  \}}D ]\}\}}||krWt||dkrW |t||    S q9|jrh|tjurh |t| S n d|  d ur{d d|   S z| W S  ty   jsjr |  Y S  w )Nr      )getis_Addr   r   r4   r9   argsis_Mulr   r   r]   r   r   r   r   rM   
is_Integerr   Oner   r   r   r   r   )rE   rc   berf   bgeg_rebuildr(   mappingpowersr+   r,   r      s2   
z)FracField._rebuild_expr.<locals>._rebuild)r(   r@   keys)rh   rE   r   r+   r   r,   _rebuild_expr   s   zFracField._rebuild_exprc                 C  sT   t tt| j| j}z
| t||}W n ty$   td| |f w | 	|S )NzGexpected an expression convertible to a rational function in %s, got %s)
dictr4   r\   r'   r%   r   r   r   rp   r   )rh   rE   r   fracr+   r+   r,   r     s   
zFracField.from_exprc                 C  s   t | S rO   r   rg   r+   r+   r,   	to_domain  s   zFracField.to_domainc                 C  s   t | j| j| jS rO   )r   r'   r(   r)   rg   r+   r+   r,   r   !  s   zFracField.to_ringrO   )rP   
__module____qualname____doc____annotations__r   rR   r[   rj   rl   rn   rs   ru   rm   rX   r~   r   r   r   __call__r   r   r   r   r+   r+   r+   r,   r$   g   s4   
 "

%#
r$   c                   @  s>  e Zd ZdZdKddZdKddZdd Zd	d
 Zdd Zdd Z	dZ
dd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd  Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Zd/d0 Zd1d2 Zd3d4 Zd5d6 Zd7d8 Zd9d: Z d;d< Z!d=d> Z"d?d@ Z#dAdB Z$dCdD Z%dKdEdFZ&dKdGdHZ'dKdIdJZ(dS )LrV   z=Element of multivariate distributed rational function field. Nc                 C  s4   |d u r	|j j}n|std|| _|| _|| _d S )Nzzero denominator)rL   rZ   ZeroDivisionErrorr-   rz   r{   )rh   r-   rz   r{   r+   r+   r,   __init__'  s   

zFracElement.__init__c                 C  s   |  | j||S rO   )	__class__r-   frz   r{   r+   r+   r,   rX   1  rk   zFracElement.raw_newc                 C  s   | j || S rO   )rX   r}   r   r+   r+   r,   r~   4  rk   zFracElement.newc                 C  s   | j dkr	td| jS )Nr   zf.denom should be 1)r{   rp   rz   r   r+   r+   r,   ro   7  s   
zFracElement.to_polyc                 C  s
   | j  S rO   )r-   r   rg   r+   r+   r,   parent<  rv   zFracElement.parentc                 C  ri   rO   )r-   rz   r{   rg   r+   r+   r,   rj   ?  rk   zFracElement.__getnewargs__c                 C  s,   | j }|d u rt| j| j| jf | _ }|S rO   )rU   rT   r-   rz   r{   )rh   rU   r+   r+   r,   rl   D  s   zFracElement.__hash__c                 C  s   |  | j | j S rO   )rX   rz   copyr{   rg   r+   r+   r,   r   J     zFracElement.copyc                 C  s8   | j |kr| S |j}| j|}| j|}|||S rO   )r-   rL   rz   r   r{   r~   )rh   	new_fieldnew_ringrz   r{   r+   r+   r,   	set_fieldM  s   
zFracElement.set_fieldc                 G  s   | j j| | jj|  S rO   )rz   as_exprr{   )rh   r'   r+   r+   r,   r   V  r   zFracElement.as_exprc                 C  sH   t |tr| j|jkr| j|jko| j|jkS | j|ko#| j| jjjkS rO   )r]   rV   r-   rz   r{   rL   rZ   r   gr+   r+   r,   rs   Y  s   zFracElement.__eq__c                 C  rt   rO   r+   r   r+   r+   r,   ru   _  rv   zFracElement.__ne__c                 C  s
   t | jS rO   )boolrz   r   r+   r+   r,   __bool__b  rv   zFracElement.__bool__c                 C  s   | j  | j fS rO   )r{   sort_keyrz   rg   r+   r+   r,   r   e  s   zFracElement.sort_keyc                 C  s"   | j |r||  | S tS rO   )r-   rm   r   NotImplemented)f1f2opr+   r+   r,   _cmph  s   zFracElement._cmpc                 C     |  |tS rO   )r   r   r   r   r+   r+   r,   __lt__n  r|   zFracElement.__lt__c                 C  r   rO   )r   r   r   r+   r+   r,   __le__p  r|   zFracElement.__le__c                 C  r   rO   )r   r   r   r+   r+   r,   __gt__r  r|   zFracElement.__gt__c                 C  r   rO   )r   r	   r   r+   r+   r,   __ge__t  r|   zFracElement.__ge__c                 C  s   |  | j| jS z"Negate all coefficients in ``f``. rX   rz   r{   r   r+   r+   r,   __pos__w  s   zFracElement.__pos__c                 C  s   |  | j | jS r   r   r   r+   r+   r,   __neg__{  s   zFracElement.__neg__c                 C  s   | j j}z||}W n4 ty?   |js<|jr<| }z||}W n ty.   Y Y dS w d||||f Y S Y dS w d|d fS )N)r   NNr   )	r-   r(   r   r   r   r   r   rz   r{   )rh   rx   r(   r   r+   r+   r,   _extract_ground  s    
zFracElement._extract_groundc                 C  s  | j }|s| S | s|S ||r5| j|jkr!| | j|j | jS | | j|j | j|j  | j|j S |j|rH| | j| j|  | jS t|trpt|jt	r[|jj |j kr[n-t|j jt	rn|j jj |krn|
| S tS t|trt|jtr|jj|jkrn|
| S | 
|S )z(Add rational functions ``f`` and ``g``. )r-   rm   r{   r~   rz   rL   r]   rV   r(   r   __radd__r   r   r   r   r   r-   r+   r+   r,   __add__  s,   
(




zFracElement.__add__c                 C  s   | j j|r| | j| j|  | jS | |\}}}|dkr-| | j| j|  | jS |s1tS | | j| | j|  | j| S Nr   r-   rL   rm   r~   rz   r{   r   r   r   cr   g_numerg_denomr+   r+   r,   r     s   "zFracElement.__radd__c                 C  sn  | j }|s| S | s| S ||r6| j|jkr"| | j|j | jS | | j|j | j|j  | j|j S |j|rI| | j| j|  | jS t|trqt|jt	r\|jj |j kr\n-t|j jt	ro|j jj |kro|
| S tS t|trt|jtr|jj|jkrn|
| S | |\}}}|dkr| | j| j|  | jS |stS | | j| | j|  | j| S )z-Subtract rational functions ``f`` and ``g``. r   )r-   rm   r{   r~   rz   rL   r]   rV   r(   r   __rsub__r   r   r   r   r   r   r-   r   r   r   r+   r+   r,   __sub__  s6   
(



"zFracElement.__sub__c                 C  s   | j j|r| | j | j|  | jS | |\}}}|dkr/| | j | j|  | jS |s3tS | | j | | j|  | j| S r   r   r   r+   r+   r,   r     s   $zFracElement.__rsub__c                 C  s   | j }| r|s
|jS ||r| | j|j | j|j S |j|r-| | j| | jS t|trUt|j	t
r@|j	j |j kr@n-t|j j	t
rS|j j	j |krS|| S tS t|trmt|j	trh|j	j|jkrhn|| S | |S )z-Multiply rational functions ``f`` and ``g``. )r-   rW   rm   r~   rz   r{   rL   r]   rV   r(   r   __rmul__r   r   r   r   r+   r+   r,   __mul__  s$   





zFracElement.__mul__c                 C  sn   | j j|r| | j| | jS | |\}}}|dkr'| | j| | jS |s+tS | | j| | j| S r   r   r   r+   r+   r,   r     s   zFracElement.__rmul__c                 C  s   | j }|st||r| | j|j | j|j S |j|r*| | j| j| S t|trRt|j	t
r=|j	j |j kr=n-t|j j	t
rP|j j	j |krP|| S tS t|trjt|j	tre|j	j|jkren|| S | |\}}}|dkr| | j| j| S |stS | | j| | j| S )z0Computes quotient of fractions ``f`` and ``g``. r   )r-   r   rm   r~   rz   r{   rL   r]   rV   r(   r   __rtruediv__r   r   r   r   r   r+   r+   r,   __truediv__  s.   




zFracElement.__truediv__c                 C  sv   | st | jj|r| | j| | jS | |\}}}|dkr+| | j| | jS |s/tS | | j| | j| S r   )	r   r-   rL   rm   r~   r{   rz   r   r   r   r+   r+   r,   r   :  s   zFracElement.__rtruediv__c                 C  sD   |dkr|  | j| | j| S | st|  | j|  | j|  S )z+Raise ``f`` to a non-negative power ``n``. r   )rX   rz   r{   r   )r   nr+   r+   r,   __pow__I  s
   zFracElement.__pow__c                 C  s:   |  }| | j|| j | j| j|  | jd S )a  Computes partial derivative in ``x``.

        Examples
        ========

        >>> from sympy.polys.fields import field
        >>> from sympy.polys.domains import ZZ

        >>> _, x, y, z = field("x,y,z", ZZ)
        >>> ((x**2 + y)/(z + 1)).diff(x)
        2*x/(z + 1)

        r8   )ro   r~   rz   diffr{   )r   xr+   r+   r,   r   R  s   2zFracElement.diffc                 G  sP   dt |  k r| jjkrn n| tt| jj|S td| jjt |f )Nr   z1expected at least 1 and at most %s values, got %s)r>   r-   rN   evaluater4   r\   r%   rp   )r   r5   r+   r+   r,   r   c  s    zFracElement.__call__c                 C  sx   t |tr|d u rdd |D }| j|| j|}}n| }| j||| j||}}|j }|||S )Nc                 S     g | ]
\}}|  |fqS r+   ro   r0   Xar+   r+   r,   r2   k      z(FracElement.evaluate.<locals>.<listcomp>)	r]   r4   rz   r   r{   ro   rL   r   r~   )r   r   r   rz   r{   r-   r+   r+   r,   r   i  s   
zFracElement.evaluatec                 C  sn   t |tr|d u rdd |D }| j|| j|}}n| }| j||| j||}}| ||S )Nc                 S  r   r+   r   r   r+   r+   r,   r2   v  r   z$FracElement.subs.<locals>.<listcomp>)r]   r4   rz   subsr{   ro   r~   )r   r   r   rz   r{   r+   r+   r,   r   t  s   zFracElement.subsc                 C  s   t rO   )r   )r   r   r   r+   r+   r,   compose~  s   zFracElement.composerO   ))rP   r   r   r   r   rX   r~   ro   r   rj   rU   rl   r   r   r   rs   ru   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r+   r+   r+   r,   rV   $  sN    


	&!	


rV   N)?r   
__future__r   	functoolsr   operatorr   r   r   r   r   r	   sympy.core.exprr
   sympy.core.modr   sympy.core.numbersr   sympy.core.singletonr   sympy.core.symbolr   sympy.core.sympifyr   r   &sympy.functions.elementary.exponentialr   sympy.polys.domains.domainr   !sympy.polys.domains.domainelementr   !sympy.polys.domains.fractionfieldr   "sympy.polys.domains.polynomialringr   sympy.polys.constructorr   sympy.polys.orderingsr   r   sympy.polys.polyerrorsr   sympy.polys.polyoptionsr   sympy.polys.polyutilsr   sympy.polys.ringsr   r   sympy.printing.defaultsr   sympy.utilitiesr    sympy.utilities.iterablesr!   sympy.utilities.magicr"   r-   r.   r3   rK   r$   rV   r+   r+   r+   r,   <module>   sH     
5 >