B
    ddR                 @   s  d Z ddlmZ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( ddl)m*Z* ddl+m,Z, ddl-m.Z. ddl/m0Z0 ddl1m2Z2 ddl3m4Z4 ddl5m6Z6 e2e&fddZ7e2e&fddZ8e2e&fddZ9e2dd  Z:i Z;G d!d" d"e0Z<G d#d$ d$ee0eZ=d%S )&z!Sparse rational function fields.     )AnyDict)reduce)addmulltlegtge)Expr)Mod)Exp1)S)Symbol)CantSympifysympify)ExpBase)DomainElement)FractionField)PolynomialRing)construct_domain)lex)CoercionFailed)build_options)_parallel_dict_from_expr)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&   _/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/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$   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%   r&   r&   r'   vfield*   s    r.   c          	   O   s   d}t | s| gd } }ttt| } t||}g }x| D ]}||  q:W t||\}}|jdkrt	dd |D g }t
||d\|_}	t|j|j|j}
g }x6tdt|dD ]"}||
t|||d   qW |r|
|d fS |
|fS d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)r+   repr&   r&   r'   r-   Y   s    zsfield.<locals>.<listcomp>)optr      )r   r/   mapr   r   extendZas_numer_denomr   r#   sumr   r    r!   r$   rangelenappendtuple)exprsr"   optionsZsingler2   ZnumdensexprZrepsZcoeffs_r%   Zfracsir&   r&   r'   sfield1   s&    


"r@   c               @   s   e Zd ZdZ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dZd$ddZdd Zdd Zdd ZeZdd Zdd Zdd  Zd!d" ZdS )%r    z2Multivariate distributed rational function field. c             C   s  ddl m} ||||}|j}|j}|j}|j}| j||||f}t|}|d krt	
| }||_t||_||_tdtfd|i|_||_||_||_||_||j|_||j|_| |_x@t|j|jD ].\}	}
t|	tr|	j}t||st|||
 qW |t|< |S )Nr   )PolyRingFracElementr(   )sympy.polys.ringsrA   r"   ngensr#   r$   __name___field_cachegetobject__new___hash_tuplehash_hashringtyperB   dtypezeroone_gensr!   zip
isinstancer   r*   hasattrsetattr)clsr"   r#   r$   rA   rM   rD   rJ   objsymbol	generatorr*   r&   r&   r'   rI   k   s8    






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&   )rO   )r+   gen)selfr&   r'   r-      s    z#FracField._gens.<locals>.<listcomp>)r:   rM   r!   )r\   r&   )r\   r'   rR      s    zFracField._gensc             C   s   | j | j| jfS )N)r"   r#   r$   )r\   r&   r&   r'   __getnewargs__   s    zFracField.__getnewargs__c             C   s   | j S )N)rL   )r\   r&   r&   r'   __hash__   s    zFracField.__hash__c             C   s2   t || jr| j| S td| j|f d S )Nzexpected a %s, got %s instead)rT   rO   rM   indexto_poly
ValueError)r\   r[   r&   r&   r'   r_      s    zFracField.indexc             C   s2   t |to0| j| j| j| jf|j|j|j|jfkS )N)rT   r    r"   rD   r#   r$   )r\   otherr&   r&   r'   __eq__   s    
zFracField.__eq__c             C   s
   | |k S )Nr&   )r\   rb   r&   r&   r'   __ne__   s    zFracField.__ne__Nc             C   s   |  ||S )N)rO   )r\   numerdenomr&   r&   r'   raw_new   s    zFracField.raw_newc             C   s*   |d kr| j j}||\}}| ||S )N)rM   rQ   cancelrg   )r\   re   rf   r&   r&   r'   new   s     zFracField.newc             C   s   | j |S )N)r#   convert)r\   elementr&   r&   r'   
domain_new   s    zFracField.domain_newc             C   s   y|  | j|S  tk
r~   | j}|jsx|jrx| j}| }||}||	|}||
|}| ||S  Y nX d S )N)ri   rM   
ground_newr   r#   is_Fieldhas_assoc_Field	get_fieldrj   re   rf   rg   )r\   rk   r#   rM   ground_fieldre   rf   r&   r&   r'   rm      s    
zFracField.ground_newc             C   sv  t |trp| |jkr|S t | jtr<| jj|jkr<| |S t | jtrd| jj |jkrd| |S t	dnt |t
r | \}}t | jtr|j| jjkr| j|}n8t | jtr|j| jj kr| j|}n|| j}| j|}| ||S t |tr<t|dkr<tt| jj|\}}| ||S t |trRt	dn t |trh| |S | |S d S )N
conversionr3   Zparsing)rT   rB   r(   r#   r   rm   r   rM   to_fieldNotImplementedErrorr   Zclear_denomsto_ringset_ringrg   r:   r8   r/   r4   Zring_newri   strr   	from_expr)r\   rk   rf   re   r&   r&   r'   	field_new   s:    





zFracField.field_newc                s:   | j tdd  D  fdd  t|S )Nc             s   s*   | ]"}|j st|tr|| fV  qd S )N)is_PowrT   r   as_base_exp)r+   r[   r&   r&   r'   	<genexpr>   s    z*FracField._rebuild_expr.<locals>.<genexpr>c                s   | }|d k	r|S | jr2tttt | jS | jrNtttt | jS | j	sbt
| ttfr|  \}}x@D ]8\}\}}||krtt||dkrt |t||  S qtW |jr|tjk	rЈ |t| S y
| S  tk
r   js
jr
 | S  Y nX d S )Nr   )rG   Zis_Addr   r   r/   r4   argsZis_Mulr   rz   rT   r   r   r{   r   intZ
is_Integerr   ZOnerj   r   rn   ro   rp   )r=   rZ   ber[   bgeg)_rebuildr#   mappingpowersr&   r'   r      s(    

z)FracField._rebuild_expr.<locals>._rebuild)r#   r:   keysr   )r\   r=   r   r&   )r   r#   r   r   r'   _rebuild_expr   s    zFracField._rebuild_exprc             C   sZ   t tt| j| j}y| ||}W n$ tk
rJ   td| |f Y nX | |S d S )NzGexpected an expression convertible to a rational function in %s, got %s)	dictr/   rS   r"   r!   r   r   ra   ry   )r\   r=   r   fracr&   r&   r'   rx     s    zFracField.from_exprc             C   s   t | S )N)r   )r\   r&   r&   r'   	to_domain  s    zFracField.to_domainc             C   s   ddl m} || j| j| jS )Nr   )rA   )rC   rA   r"   r#   r$   )r\   rA   r&   r&   r'   ru     s    zFracField.to_ring)N)N)rE   
__module____qualname____doc__r   rI   rR   r]   r^   r_   rc   rd   rg   ri   rl   rm   ry   __call__r   rx   r   ru   r&   r&   r&   r'   r    h   s$   &

%!
r    c               @   s<  e Zd ZdZdKddZd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%dLdEdFZ&dMdGdHZ'dNdIdJZ(dS )OrB   z=Element of multivariate distributed rational function field. Nc             C   s0   |d kr| j jj}n|s td|| _|| _d S )Nzzero denominator)r(   rM   rQ   ZeroDivisionErrorre   rf   )r\   re   rf   r&   r&   r'   __init__  s    zFracElement.__init__c             C   s   |  ||S )N)	__class__)fre   rf   r&   r&   r'   rg   (  s    zFracElement.raw_newc             C   s   | j || S )N)rg   rh   )r   re   rf   r&   r&   r'   ri   *  s    zFracElement.newc             C   s   | j dkrtd| jS )N   zf.denom should be 1)rf   ra   re   )r   r&   r&   r'   r`   -  s    
zFracElement.to_polyc             C   s
   | j  S )N)r(   r   )r\   r&   r&   r'   parent2  s    zFracElement.parentc             C   s   | j | j| jfS )N)r(   re   rf   )r\   r&   r&   r'   r]   5  s    zFracElement.__getnewargs__c             C   s,   | j }|d kr(t| j| j| jf | _ }|S )N)rL   rK   r(   re   rf   )r\   rL   r&   r&   r'   r^   :  s    zFracElement.__hash__c             C   s   |  | j | j S )N)rg   re   copyrf   )r\   r&   r&   r'   r   @  s    zFracElement.copyc             C   s<   | j |kr| S |j}| j|}| j|}|||S d S )N)r(   rM   re   rv   rf   ri   )r\   Z	new_fieldZnew_ringre   rf   r&   r&   r'   	set_fieldC  s    
zFracElement.set_fieldc             G   s   | j j| | jj|  S )N)re   as_exprrf   )r\   r"   r&   r&   r'   r   L  s    zFracElement.as_exprc             C   sL   t |tr.| j|jkr.| j|jko,| j|jkS | j|koF| j| jjjkS d S )N)rT   rB   r(   re   rf   rM   rQ   )r   gr&   r&   r'   rc   O  s    zFracElement.__eq__c             C   s
   | |k S )Nr&   )r   r   r&   r&   r'   rd   U  s    zFracElement.__ne__c             C   s
   t | jS )N)boolre   )r   r&   r&   r'   __bool__X  s    zFracElement.__bool__c             C   s   | j  | j fS )N)rf   sort_keyre   )r\   r&   r&   r'   r   [  s    zFracElement.sort_keyc             C   s(   t || jjr ||  | S tS d S )N)rT   r(   rO   r   NotImplemented)f1f2opr&   r&   r'   _cmp^  s    zFracElement._cmpc             C   s   |  |tS )N)r   r   )r   r   r&   r&   r'   __lt__d  s    zFracElement.__lt__c             C   s   |  |tS )N)r   r   )r   r   r&   r&   r'   __le__f  s    zFracElement.__le__c             C   s   |  |tS )N)r   r	   )r   r   r&   r&   r'   __gt__h  s    zFracElement.__gt__c             C   s   |  |tS )N)r   r
   )r   r   r&   r&   r'   __ge__j  s    zFracElement.__ge__c             C   s   |  | j| jS )z"Negate all coefficients in ``f``. )rg   re   rf   )r   r&   r&   r'   __pos__m  s    zFracElement.__pos__c             C   s   |  | j | jS )z"Negate all coefficients in ``f``. )rg   re   rf   )r   r&   r&   r'   __neg__q  s    zFracElement.__neg__c             C   s   | j j}y||}W nb tk
rx   |jst|jrt| }y||}W n tk
r\   Y nX d||||fS dS X d|d fS d S )N)r   NNr   )	r(   r#   rj   r   rn   ro   rp   re   rf   )r\   rk   r#   rq   r&   r&   r'   _extract_groundu  s    zFracElement._extract_groundc             C   s(  | j }|s| S | s|S t||jrn| j|jkrD| | j|j | jS | | j|j | j|j  | j|j S nt||jjr| | j| j|  | jS t|trt|jt	r|jj |j krn*t|j jt	r|j jj |kr|
| S tS n6t|trt|jtr|jj|jkrn
|
| S | 
|S )z(Add rational functions ``f`` and ``g``. )r(   rT   rO   rf   ri   re   rM   rB   r#   r   __radd__r   r   r   )r   r   r(   r&   r&   r'   __add__  s,    *


zFracElement.__add__c             C   s   t || jjjr*| | j| j|  | jS | |\}}}|dkr\| | j| j|  | jS |sdtS | | j| | j|  | j| S d S )Nr   )	rT   r(   rM   rO   ri   re   rf   r   r   )r   cr   g_numerg_denomr&   r&   r'   r     s    zFracElement.__radd__c             C   s  | j }|s| S | s| S t||jrp| j|jkrF| | j|j | jS | | j|j | j|j  | j|j S nt||jjr| | j| j|  | jS t|trt|jt	r|jj |j krn*t|j jt	r|j jj |kr|
| S tS n6t|tr t|jtr|jj|jkrn
|
| S | |\}}}|dkrT| | j| j|  | jS |s^tS | | j| | j|  | j| S dS )z-Subtract rational functions ``f`` and ``g``. r   N)r(   rT   rO   rf   ri   re   rM   rB   r#   r   __rsub__r   r   r   r   )r   r   r(   r   r   r   r&   r&   r'   __sub__  s6    *



zFracElement.__sub__c             C   s   t || jjjr,| | j | j|  | jS | |\}}}|dkr`| | j | j|  | jS |shtS | | j | | j|  | j| S d S )Nr   )	rT   r(   rM   rO   ri   re   rf   r   r   )r   r   r   r   r   r&   r&   r'   r     s    zFracElement.__rsub__c             C   s   | j }| r|s|jS t||jr<| | j|j | j|j S t||jjr^| | j| | jS t|trt|j	t
r|j	j |j krqt|j j	t
r|j j	j |kr|| S tS n0t|trt|j	tr|j	j|jkrn
|| S | |S )z-Multiply rational functions ``f`` and ``g``. )r(   rP   rT   rO   ri   re   rf   rM   rB   r#   r   __rmul__r   r   r   )r   r   r(   r&   r&   r'   __mul__  s$    



zFracElement.__mul__c             C   st   t || jjjr$| | j| | jS | |\}}}|dkrP| | j| | jS |sXtS | | j| | j| S d S )Nr   )	rT   r(   rM   rO   ri   re   rf   r   r   )r   r   r   r   r   r&   r&   r'   r     s    zFracElement.__rmul__c             C   s0  | j }|stnt||jr8| | j|j | j|j S t||jjrZ| | j| j| S t|trt|j	t
r|j	j |j krqt|j j	t
r|j j	j |kr|| S tS n0t|trt|j	tr|j	j|jkrn
|| S | |\}}}|dkr
| | j| j| S |stS | | j| | j| S dS )z0Computes quotient of fractions ``f`` and ``g``. r   N)r(   r   rT   rO   ri   re   rf   rM   rB   r#   r   __rtruediv__r   r   r   r   )r   r   r(   r   r   r   r&   r&   r'   __truediv__  s.    




zFracElement.__truediv__c             C   s~   | s
t n$t|| jjjr.| | j| | jS | |\}}}|dkrZ| | j| | jS |sbt	S | | j| | j| S d S )Nr   )
r   rT   r(   rM   rO   ri   rf   re   r   r   )r   r   r   r   r   r&   r&   r'   r   0  s    zFracElement.__rtruediv__c             C   sJ   |dkr |  | j| | j| S | s*tn|  | j|  | j|  S dS )z+Raise ``f`` to a non-negative power ``n``. r   N)rg   re   rf   r   )r   nr&   r&   r'   __pow__?  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)

        r3   )r`   ri   re   diffrf   )r   xr&   r&   r'   r   H  s    zFracElement.diffc             G   sT   dt |  k r| jjkr8n n| tt| jj|S td| jjt |f d S )Nr   z1expected at least 1 and at most %s values, got %s)r8   r(   rD   evaluater/   rS   r!   ra   )r   r0   r&   r&   r'   r   Y  s     zFracElement.__call__c             C   sx   t |tr<|d kr<dd |D }| j|| j| }}n&| }| j||| j|| }}|j }|||S )Nc             S   s   g | ]\}}|  |fqS r&   )r`   )r+   Xar&   r&   r'   r-   a  s    z(FracElement.evaluate.<locals>.<listcomp>)	rT   r/   re   r   rf   r`   rM   rs   ri   )r   r   r   re   rf   r(   r&   r&   r'   r   _  s    
zFracElement.evaluatec             C   sn   t |tr<|d kr<dd |D }| j|| j| }}n&| }| j||| j|| }}| ||S )Nc             S   s   g | ]\}}|  |fqS r&   )r`   )r+   r   r   r&   r&   r'   r-   l  s    z$FracElement.subs.<locals>.<listcomp>)rT   r/   re   subsrf   r`   ri   )r   r   r   re   rf   r&   r&   r'   r   j  s    zFracElement.subsc             C   s   t d S )N)rt   )r   r   r   r&   r&   r'   composet  s    zFracElement.compose)N)N)N)N))rE   r   r   r   r   rg   ri   r`   r   r]   rL   r^   r   r   r   rc   rd   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'   rB     sL   
		&!	


rB   N)>r   typingr   r   ZtDict	functoolsr   operatorr   r   r   r   r	   r
   Zsympy.core.exprr   Zsympy.core.modr   Zsympy.core.numbersr   Zsympy.core.singletonr   Zsympy.core.symbolr   Zsympy.core.sympifyr   r   Z&sympy.functions.elementary.exponentialr   Z!sympy.polys.domains.domainelementr   Z!sympy.polys.domains.fractionfieldr   Z"sympy.polys.domains.polynomialringr   Zsympy.polys.constructorr   Zsympy.polys.orderingsr   Zsympy.polys.polyerrorsr   Zsympy.polys.polyoptionsr   Zsympy.polys.polyutilsr   rC   r   Zsympy.printing.defaultsr   Zsympy.utilitiesr   Zsympy.utilities.iterablesr   Zsympy.utilities.magicr   r(   r)   r.   r@   rF   r    rB   r&   r&   r&   r'   <module>   sD    5 5