a RG5dk,@sdZddlmZddlmZddlmZddlmZddl m Z m Z m Z m Z mZddlmZddlmZdd lmZdd lmZdd lmZd d ZddZddZddZeddZdS)z0Tools for constructing domains for expressions. )prod)sympify) pure_complex)ordered)ZZQQZZ_IQQ_IEX) ComplexField) RealField) build_options)parallel_dict_from_basic)publiccsd}}}}g}|jdur(dd}ndd}|D]}|jrJ|jsd}q4|jrj|rZdSd}||q4t|} | rd}| \} } | jr| jr| jr| js4d}q4qd}| jr|| | jr|| q4||r|rdSd}q4dSq4|rtdd|Dnd } |rt||\} nh|r2|r2t| d n>|rDt | d n,|sR|j rb|r\t nt n|rlt ntfd d |D} | fS) z?Handle simple domains, e.g.: ZZ, QQ, RR and algebraic domains. FTcSs |jo |jSN is_number is_algebraiccoeffrS/var/www/html/django/DPS/env/lib/python3.9/site-packages/sympy/polys/constructor.pyz#_construct_simple..cSsdS)NFrrrrrrrNcss|] }|jVqdSr_prec.0crrr >rz$_construct_simple..5preccsg|]}|qSr) from_sympy)rrdomainrr Lrz%_construct_simple..) extension is_Rational is_Integeris_Floatappendrmax_construct_algebraicr r fieldr rrr)coeffsopt rationalsfloats complexesZ algebraics float_numbersrr is_complexxymax_precresultrr$r_construct_simplesX          r:c sddlm}tfdd|}tt|ddd\}}tddt|D}t|fj j fd d|D}t t|fd d fd d|D}|fS) zDWe know that coefficients are algebraic so construct the extension. r)primitive_elementcspg}|D]b}|jr"dt|f}n>|jr8d|jf}n(|jrNd|jf}nd|f}|||q|S)NQ+*e)r(rr#is_Addargsis_Muladdr+)rAtreesatree) build_treesextsrrrGWs  z)_construct_algebraic..build_treesT)expolyscSsg|]\}}||qSrr)rsextrrrr&jrz(_construct_algebraic..csg|]}j|tqSr)dtype from_listr)rh)r%grrr&nrcsz|\}}|dkr"j|gtS|dkrDtfdd|DjS|dkrbtfdd|DS|dkrr|StdS)Nr<r=c3s|]}|VqdSrrrrE convert_treerrrvrz=_construct_algebraic..convert_tree..r>c3s|]}|VqdSrrrQrRrrrxrr?)rMrNrsumzeror RuntimeError)rFoprA)rSr%exts_maprPrrrSqsz*_construct_algebraic..convert_treecsg|] }|qSrr)rrFrRrrr&~r) sympy.polys.numberfieldsr;setlistrrTzipralgebraic_fieldrepdict) r/r0r;rDspanHrootZexts_domr9r)rGrSr%rHrXrPrr-Qs   r-cCsgg}}|D]$}|\}}||||qt||\}}|sLdS|jdurtdd|DrldSt} |D] } | j} | | @rdS| | O} qvt|} t|d} |d| }|| d}|jrd}n8dd| }}|D]$}t|dks||vrd}qqt}|sbt ||D]@\}}||}| D]$\}}||}| ||||<q6qn:t ||D].\}}| t || t |qld}}}g}|D]}|jr|jsNd}n|jrd}||nlt|}|durd}|\}}|jr&|jr&|jr |jsNd}n(d}|jr<|||jr||q|rjtd d|Dnd }|r|rt|d }n:|rt|d }n(|r|rt}nt}n|rt}nt}g}|s|j|}|D]6}| D]\}}||||<q|||qnv|j|}t ||D]`\}}| D]\}}||||<q6| D]\}}||||<qX||||fq&||fS) z.TF)rcss|] }|jVqdSrrrrrrrrr r!)as_numer_denomr+r compositeanyrZ free_symbolslenr.r\itemsrCupdater[valuesr(r)r*rr,r r r rrr poly_ringr# frac_field)r/r0numersdenomsrnumerdenomrJgensZ all_symbolsrcsymbolsnk fractionszerosmonomr1r2r3r4r5r6r7r8groundr9r%rrr_construct_composites                   r|cCs,tg}}|D]}|||q||fS)z6The last resort case, i.e. use the expression domain. )r r+r#)r/r0r%r9rrrr_construct_expressions r}cKst|}t|drLt|trF|s,gg}}qJttt|\}}qR|}n|g}ttt|}t ||}|dur|dur|\}}qt ||\}}n:|j durd}n t ||}|dur|\}}nt ||\}}t|drt|tr|ttt||fS||fSn ||dfSdS)aT Construct a minimal domain for a list of expressions. Explanation =========== Given a list of normal SymPy expressions (of type :py:class:`~.Expr`) ``construct_domain`` will find a minimal :py:class:`~.Domain` that can represent those expressions. The expressions will be converted to elements of the domain and both the domain and the domain elements are returned. Parameters ========== obj: list or dict The expressions to build a domain for. **args: keyword arguments Options that affect the choice of domain. Returns ======= (K, elements): Domain and list of domain elements The domain K that can represent the expressions and the list or dict of domain elements representing the same expressions as elements of K. Examples ======== Given a list of :py:class:`~.Integer` ``construct_domain`` will return the domain :ref:`ZZ` and a list of integers as elements of :ref:`ZZ`. >>> from sympy import construct_domain, S >>> expressions = [S(2), S(3), S(4)] >>> K, elements = construct_domain(expressions) >>> K ZZ >>> elements [2, 3, 4] >>> type(elements[0]) # doctest: +SKIP >>> type(expressions[0]) If there are any :py:class:`~.Rational` then :ref:`QQ` is returned instead. >>> construct_domain([S(1)/2, S(3)/4]) (QQ, [1/2, 3/4]) If there are symbols then a polynomial ring :ref:`K[x]` is returned. >>> from sympy import symbols >>> x, y = symbols('x, y') >>> construct_domain([2*x + 1, S(3)/4]) (QQ[x], [2*x + 1, 3/4]) >>> construct_domain([2*x + 1, y]) (ZZ[x,y], [2*x + 1, y]) If any symbols appear with negative powers then a rational function field :ref:`K(x)` will be returned. >>> construct_domain([y/x, x/(1 - y)]) (ZZ(x,y), [y/x, -x/(y - 1)]) Irrational algebraic numbers will result in the :ref:`EX` domain by default. The keyword argument ``extension=True`` leads to the construction of an algebraic number field :ref:`QQ(a)`. >>> from sympy import sqrt >>> construct_domain([sqrt(2)]) (EX, [EX(sqrt(2))]) >>> construct_domain([sqrt(2)], extension=True) # doctest: +SKIP (QQ, [ANP([1, 0], [1, 0, -2], QQ)]) See also ======== Domain Expr __iter__NFr) r hasattr isinstancer_r[r\rkmaprr:r}rgr|)objrAr0monomsr/r9r%rrrconstruct_domain s2S           rN)__doc__mathr sympy.corersympy.core.evalfrsympy.core.sortingrsympy.polys.domainsrrrr r Z sympy.polys.domains.complexfieldr Zsympy.polys.domains.realfieldr Zsympy.polys.polyoptionsr sympy.polys.polyutilsrsympy.utilitiesrr:r-r|r}rrrrrs          B2}