a Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZddlZm[Z[ddlZm\Z\e]j^Z_Gddde]Z`Gddde`Zad Zbd Zcd Zdd ecedfZed d d fddZfefddddea_gefddecdecdedea_hefddecdecdedea_iefddecdecdedea_jefd d!ecd"ecd#edea_kefd$d%ecd&ecd'ea_lefd(eed)ecd*edea_meajhea_neajjea_oeajkea_peajqea_rGd+d,d,eaZsGd-d.d.e`ZteuetfZvGd/d0d0e]Zwz$d1d2lxZxexjyzetexj{zeaWne|yYn0d2S)3) basestringexec_)WMPZMPZ_ZEROMPZ_ONE int_typesrepr_dps round_floor round_ceiling dps_to_prec round_nearest prec_to_dps ComplexResult to_pickable from_pickable normalizefrom_int from_float from_npfloat from_Decimalfrom_strto_intto_floatto_str from_rational from_man_expfonefzerofinffninffnanmpf_absmpf_posmpf_negmpf_addmpf_submpf_mul mpf_mul_intmpf_div mpf_rdiv_int mpf_pow_intmpf_modmpf_eqmpf_cmpmpf_ltmpf_gtmpf_lempf_gempf_hashmpf_randmpf_sumbitcountto_fixed mpc_to_strmpc_to_complexmpc_hashmpc_posmpc_is_nonzerompc_neg mpc_conjugatempc_absmpc_add mpc_add_mpfmpc_sub mpc_sub_mpfmpc_mul mpc_mul_mpf mpc_mul_intmpc_div mpc_div_mpfmpc_pow mpc_pow_mpf mpc_pow_int mpc_mpf_divmpf_powmpf_pi mpf_degreempf_empf_phimpf_ln2mpf_ln10 mpf_euler mpf_catalan mpf_apery mpf_khinchin mpf_glaisher mpf_twinprime mpf_mertensr)rational) function_docsc@seZdZdZgZddZdS) mpnumericzBase class for mpf and mpc.cCstdSN)NotImplementedError)clsvalrad/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/mpmath/ctx_mp_python.py__new__$szmpnumeric.__new__N)__name__ __module__ __qualname____doc__ __slots__rcrarararbr\!sr\c@s|eZdZdZdgZefddZeddZeddZ ed d Z e d d Z e d d Z e dd Ze dd Ze dd Ze dd Zdd ZddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&ZeZd'd(Zd)d*Zd+d,Z d-d.Z!d/d0Z"d1d2Z#d3d4Z$d5d6Z%d7d8Z&d9d:Z'd;d<Z(d=d>Z)d?d@Z*dAdBZ+dCdDZ,dLdFdGZ-dHdIZ.dJdKZ/dES)M_mpfz An mpf instance holds a real-valued floating-point number. mpf:s work analogously to Python floats, but support arbitrary-precision arithmetic. _mpf_c Ks*|jj\}}|r<|d|}d|vr0t|d}|d|}t||ur|j\}}}}|sb|rb|St|} t||||||| _| St|turt |dkrt|} t |d|d||| _| St |dkr|\}}}}t|} t|t |||||| _| St n$t|} t ||||||| _| SdS) zA new mpf can be created from a Python float, an int, a or a decimal string representing a number in floating-point format.precdpsroundingrN)context_prec_roundinggetr typerjnewrtuplelenrr ValueErrorr"mpf_convert_arg) r_r`kwargsrkrmsignmanexpbcvrararbrc/s6        z _mpf.__new__cCst|trt|St|tr$t|St|tr:t|||St||jjrT| ||St |drd|j St |dr|j | ||}t |dr|j St |dr|j\}}||kr|Stdtdt|dS)Nrj_mpmath__mpi_z,can only create mpf from zero-width intervalcannot create mpf from ) isinstancerrfloatrrrrqconstantfunchasattrrjconvertrrrx TypeErrorrepr)r_xrkrmtabrararbryPs    z_mpf.mpf_convert_argcCst|trt|St|tr$t|St|tr:|j|St|tj r`|j \}}t |||jj St |drp|jSt |dr|j|j|jj}t |dr|jS|StS)Nrjr)rrrrr complex_typesrqmpcrZmpq_mpq_rrkrrjrrrrNotImplemented)r_rpqrrararbmpf_convert_rhsbs    z_mpf.mpf_convert_rhscCs&||}t|tur"|j|S|Sr])rrtrvrqmake_mpf)r_rrararbmpf_convert_lhsrs   z_mpf.mpf_convert_lhscCs|jddS)Nrrjselfrararbyz _mpf.cCs |jdSNrrrrararbrzrcCs |jdS)Nrnrrrararbr{rcCs |jdS)Nrrrrararbr|rcCs|Sr]rarrararbr~rcCs|jjSr])rqZzerorrararbrrcCs|Sr]rarrararbrrcCs t|jSr])rrjrrararb __getstate__rz_mpf.__getstate__cCst||_dSr])rrjrr`rararb __setstate__rz_mpf.__setstate__cCs$|jjrt|Sdt|j|jjS)Nz mpf('%s'))rqprettystrrrjZ _repr_digitssrararb__repr__sz _mpf.__repr__cCst|j|jjSr])rrjrq _str_digitsrrararb__str__rz _mpf.__str__cCs t|jSr])r2rjrrararb__hash__rz _mpf.__hash__cCstt|jSr])intrrjrrararb__int__rz _mpf.__int__cCstt|jSr])longrrjrrararb__long__rz _mpf.__long__cCst|j|jjddSNr)rnd)rrjrqrrrrararb __float__rz_mpf.__float__cCs tt|Sr])complexrrrararb __complex__rz_mpf.__complex__cCs |jtkSr])rjrrrararb __nonzero__rz_mpf.__nonzero__cCs,|j\}}\}}||}t|j|||_|Sr])_ctxdatar!rjrr_rurkrmrrararb__abs__sz _mpf.__abs__cCs,|j\}}\}}||}t|j|||_|Sr])rr"rjrrararb__pos__sz _mpf.__pos__cCs,|j\}}\}}||}t|j|||_|Sr])rr#rjrrararb__neg__sz _mpf.__neg__cCs4t|dr|j}n||}|tur(|S||j|SNrj)rrjrr)rrrrararb_cmps   z _mpf._cmpcCs ||tSr])rr-rrrararb__cmp__rz _mpf.__cmp__cCs ||tSr])rr.rrararb__lt__rz _mpf.__lt__cCs ||tSr])rr/rrararb__gt__rz _mpf.__gt__cCs ||tSr])rr0rrararb__le__rz _mpf.__le__cCs ||tSr])rr1rrararb__ge__rz _mpf.__ge__cCs||}|tur|S| Sr]__eq__r)rrrrararb__ne__s z _mpf.__ne__cCs\|j\}}\}}t|tvr>||}tt||j|||_|S||}|turT|S||Sr])rrtrr%rrjrrrrr_rurkrmrrararb__rsub__s  z _mpf.__rsub__cCsV|j\}}\}}t|tr8||}t||j|||_|S||}|turN|S||Sr])rrrr)rjrrrrararb__rdiv__s  z _mpf.__rdiv__cCs||}|tur|S||Sr]rrrrararb__rpow__s z _mpf.__rpow__cCs||}|tur|S||Sr]rrrararb__rmod__s z _mpf.__rmod__cCs |j|Sr])rqsqrtrrararbrsz _mpf.sqrtNcCs|j||||Sr]rqZalmosteqrrZrel_epsZabs_epsrararbaesz_mpf.aecCs t|j|Sr])r6rj)rrkrararbr6sz _mpf.to_fixedcGstt|g|RSr])roundr)rargsrararb __round__sz_mpf.__round__)NN)0rdrerfrgrhrrc classmethodryrrpropertyZman_expr|r}r~realimag conjugaterrrrrrrrrr__bool__rrrrrrrrrrrrrrrrr6rrarararbri'sZ !             ria  def %NAME%(self, other): mpf, new, (prec, rounding) = self._ctxdata sval = self._mpf_ if hasattr(other, '_mpf_'): tval = other._mpf_ %WITH_MPF% ttype = type(other) if ttype in int_types: %WITH_INT% elif ttype is float: tval = from_float(other) %WITH_MPF% elif hasattr(other, '_mpc_'): tval = other._mpc_ mpc = type(other) %WITH_MPC% elif ttype is complex: tval = from_float(other.real), from_float(other.imag) mpc = self.context.mpc %WITH_MPC% if isinstance(other, mpnumeric): return NotImplemented try: other = mpf.context.convert(other, strings=False) except TypeError: return NotImplemented return self.%NAME%(other) z-; obj = new(mpf); obj._mpf_ = val; return objz-; obj = new(mpc); obj._mpc_ = val; return obja try: val = mpf_pow(sval, tval, prec, rounding) %s except ComplexResult: if mpf.context.trap_complex: raise mpc = mpf.context.mpc val = mpc_pow((sval, fzero), (tval, fzero), prec, rounding) %s cCsNt}|d|}|d|}|d|}|d|}i}t|t|||S)Nz %WITH_INT%z %WITH_MPC%z %WITH_MPF%z%NAME%) mpf_binary_opreplacerglobals)nameZwith_mpfZwith_intZwith_mpccodenprararb binary_ops    rrzreturn mpf_eq(sval, tval)z$return mpf_eq(sval, from_int(other))z3return (tval[1] == fzero) and mpf_eq(tval[0], sval)__add__z)val = mpf_add(sval, tval, prec, rounding)z4val = mpf_add(sval, from_int(other), prec, rounding)z-val = mpc_add_mpf(tval, sval, prec, rounding)__sub__z)val = mpf_sub(sval, tval, prec, rounding)z4val = mpf_sub(sval, from_int(other), prec, rounding)z2val = mpc_sub((sval, fzero), tval, prec, rounding)__mul__z)val = mpf_mul(sval, tval, prec, rounding)z.val = mpf_mul_int(sval, other, prec, rounding)z-val = mpc_mul_mpf(tval, sval, prec, rounding)__div__z)val = mpf_div(sval, tval, prec, rounding)z4val = mpf_div(sval, from_int(other), prec, rounding)z-val = mpc_mpf_div(sval, tval, prec, rounding)__mod__z)val = mpf_mod(sval, tval, prec, rounding)z4val = mpf_mod(sval, from_int(other), prec, rounding)z+raise NotImplementedError("complex modulo")__pow__z.val = mpf_pow_int(sval, other, prec, rounding)z2val = mpc_pow((sval, fzero), tval, prec, rounding)c@s8eZdZdZd ddZd ddZedd Zd d ZdS) _constantzRepresents a mathematical constant with dynamic precision. When printed or used in an arithmetic operation, a constant is converted to a regular mpf at the working precision. A regular mpf can also be obtained using the operation +x.rcCs(t|}||_||_tt|d|_|S)Nr)objectrcrrgetattrr[rg)r_rrZdocnamerrararbrcNs  z_constant.__new__NcCs<|jj\}}|s|}|s|}|r(t|}|j|||Sr])rqrrr rr)rrkrlrmZprec2Z rounding2rararb__call__Us   z_constant.__call__cCs|jj\}}|||Sr])rqrrr)rrkrmrararbrj\s z_constant._mpf_cCsd|j|j|ddfS)Nz <%s: %s~>)rl)rrqZnstrrrararbrasz_constant.__repr__)r)NNN) rdrerfrgrcrrrjrrarararbrHs    rc@s&eZdZdZdgZd_mpcz An mpc represents a complex number using a pair of mpf:s (one for the real part and another for the imaginary part.) The mpc class behaves fairly similarly to Python's complex type. _mpc_rocCsdt|}t|tr$|j|j}}nt|dr:|j|_|S|j |}|j |}|j |j f|_|S)Nr) rrcrrrrrrrqmpfrj)r_rrrrararbrcns     z _mpc.__new__cCs|j|jdS)Nrorqrrrrararbrzrz _mpc.cCs|j|jdSrrrrararbr{rcCst|jdt|jdfSNror)rrrrararbr}sz_mpc.__getstate__cCst|dt|df|_dSr)rrrrararbrsz_mpc.__setstate__cCsH|jjrt|St|jdd}t|jdd}dt|j||fS)Nrpz%s(real=%s, imag=%s))rqrrrrrrtrd)rrirararbrs z _mpc.__repr__cCsdt|j|jjS)Nz(%s))r7rrqrrrararbrsz _mpc.__str__cCst|j|jjddSr)r8rrqrrrrararbrsz_mpc.__complex__cCs,|j\}}\}}||}t|j|||_|Sr])rr:rrrararbrsz _mpc.__pos__cCs,|jj\}}t|jj}t|j|||_|Sr])rqrrrurr>rrj)rrkrmrrararbrs  z _mpc.__abs__cCs,|j\}}\}}||}t|j|||_|Sr])rr<rrrararbrsz _mpc.__neg__cCs,|j\}}\}}||}t|j|||_|Sr])rr=rrrararbrsz_mpc.conjugatecCs t|jSr])r;rrrararbrsz_mpc.__nonzero__cCs t|jSr])r9rrrararbrsz _mpc.__hash__cCs.z|j|}|WSty(tYS0dSr])rqrrr)r_ryrararbmpc_convert_lhss   z_mpc.mpc_convert_lhscCsFt|ds.t|trdS||}|tur.|S|j|jkoD|j|jkS)NrF)rrrrrrrrrararbrs   z _mpc.__eq__cCs||}|tur|S| Sr]r)rrrrararbrs z _mpc.__ne__cGs tddS)Nz3no ordering relation is defined for complex numbers)r)rrararb_comparesz _mpc._comparecCsz|j\}}\}}t|dsZ||}|tur0|St|drZ||}t|j|j|||_|S||}t|j|j|||_|SNrrj)rrrrr@rrjr?rrararbrs   z _mpc.__add__cCsz|j\}}\}}t|dsZ||}|tur0|St|drZ||}t|j|j|||_|S||}t|j|j|||_|Sr)rrrrrBrrjrArrararbrs   z _mpc.__sub__cCs|j\}}\}}t|dst|trB||}t|j||||_|S||}|turX|St|dr||}t|j|j |||_|S||}||}t |j|j|||_|Sr) rrrrrErrrrDrjrCrrararbrs"     z _mpc.__mul__cCsz|j\}}\}}t|dsZ||}|tur0|St|drZ||}t|j|j|||_|S||}t|j|j|||_|Sr)rrrrrGrrjrFrrararbrs   z _mpc.__div__cCs|j\}}\}}t|tr8||}t|j||||_|S||}|turN|S||}t|drvt|j|j |||_nt |j|j|||_|Sr) rrrrJrrrrrIrjrHrrararbr s   z _mpc.__pow__cCs||}|tur|S||Sr]rrrrararbrs z _mpc.__rsub__cCsV|j\}}\}}t|tr8||}t|j||||_|S||}|turN|S||Sr])rrrrErrrrrararb__rmul__$s  z _mpc.__rmul__cCs||}|tur|S||Sr]rrrararbr/s z _mpc.__rdiv__cCs||}|tur|S||Sr]rrrararbr5s z _mpc.__rpow__NcCs|j||||Sr]rrrararbr>sz_mpc.ae)roro)NN)*rdrerfrgrhrcrrrrrrrrrrrrrrrrrrrrrrrrrrrr__radd__rrrr __truediv__ __rtruediv__rrarararbresN     rc@seZdZddZddZddZddZd d Zd d Ze d deZ e ddeZ d.ddZ ddZ ddZddZddZd/ddZd0ddZd1d!d"Zd2d$d%Zed&d'Zd(d)Zd*d+Zd,d-Zd S)3PythonMPContextcCsdtg|_tdtfi|_tdtfi|_|jt|jg|j_|jt|jg|j_||j_ ||j_ tdt fi|_ |jt|jg|j _||j _ dS)N5rrr) r rrrtrirrrrurrqrrctxrararb__init__Gs zPythonMPContext.__init__cCst|j}||_|Sr])rurrjrrrrararbrSs zPythonMPContext.make_mpfcCst|j}||_|Sr])rurrrrararbmake_mpcXs zPythonMPContext.make_mpccCs d|_|jd<d|_d|_dS)NrrorF)_precrr_dps trap_complexrrararbdefault]szPythonMPContext.defaultcCs(tdt||_|jd<t||_dS)Nrro)maxrrrrr rrnrararb _set_precbszPythonMPContext._set_preccCs(t||_|jd<tdt||_dSr)r rrrrrrrrararb_set_dpsfszPythonMPContext._set_dpscCs|jSr])rrrararbrjrzPythonMPContext.cCs|jSr])rrrararbrkrTcCst||jvr|St|tr*|t|St|trB|t|St|trf| t|j t|j fSt|j dkr~| |St|tjrztt|jt|j}Wn Yn0|j\}}t|tjr|j\}}|t|||S|r&t|tr&zt|||}||WSty$Yn0t|dr>||jSt|drV| |jSt|drt||||St|j dkrz|t |||WSYn0|!||S)a Converts *x* to an ``mpf`` or ``mpc``. If *x* is of type ``mpf``, ``mpc``, ``int``, ``float``, ``complex``, the conversion will be performed losslessly. If *x* is a string, the result will be rounded to the present working precision. Strings representing fractions or complex numbers are permitted. >>> from mpmath import * >>> mp.dps = 15; mp.pretty = False >>> mpmathify(3.5) mpf('3.5') >>> mpmathify('2.1') mpf('2.1000000000000001') >>> mpmathify('3/4') mpf('0.75') >>> mpmathify('2+3j') mpc(real='2.0', imag='3.0') numpyrjrrdecimal)"rttypesrrrrrrrrrrre npconvertnumbersRationalrZrr numerator denominatorrrrrrrrxrrjrrrrZ_convert_fallback)rrstringsrkrmrrrjrararbrms6          zPythonMPContext.convertcCszddl}t||jr&|tt|St||jr@|t|St||jrf| t|j t|j fSt dt |dS)z^ Converts *x* to an ``mpf`` or ``mpc``. *x* should be a numpy scalar. roNr)r rintegerrrrZfloatingrZcomplexfloatingrrrrr)rrrrararbrs  zPythonMPContext.npconvertcCsvt|dr|jtkSt|dr(t|jvSt|ts>t|tjrBdS||}t|ds`t|drj| |St ddS)a Return *True* if *x* is a NaN (not-a-number), or for a complex number, whether either the real or complex part is NaN; otherwise return *False*:: >>> from mpmath import * >>> isnan(3.14) False >>> isnan(nan) True >>> isnan(mpc(3.14,2.72)) False >>> isnan(mpc(3.14,nan)) True rjrFzisnan() needs a number as inputN) rrjr rrrrZrrisnanr)rrrararbrs      zPythonMPContext.isnancCst|dr|jttfvSt|drD|j\}}|ttfvpB|ttfvSt|tsZt|tjr^dS| |}t|ds|t|dr| |St ddS)a Return *True* if the absolute value of *x* is infinite; otherwise return *False*:: >>> from mpmath import * >>> isinf(inf) True >>> isinf(-inf) True >>> isinf(3) False >>> isinf(3+4j) False >>> isinf(mpc(3,inf)) True >>> isinf(mpc(inf,3)) True rjrFzisinf() needs a number as inputN) rrjrrrrrrZrrisinfr)rrreimrararbrs     zPythonMPContext.isinfcCst|drt|jdSt|drd|j\}}t|d}t|d}|tkrP|S|tkr\|S|ob|St|tszt|tjrt|S| |}t|dst|dr| |St ddS)a Determine whether *x* is "normal" in the sense of floating-point representation; that is, return *False* if *x* is zero, an infinity or NaN; otherwise return *True*. By extension, a complex number *x* is considered "normal" if its magnitude is normal:: >>> from mpmath import * >>> isnormal(3) True >>> isnormal(0) False >>> isnormal(inf); isnormal(-inf); isnormal(nan) False False False >>> isnormal(0+0j) False >>> isnormal(0+3j) True >>> isnormal(mpc(2,nan)) False rjrrz"isnormal() needs a number as inputN) rboolrjrrrrrZrrisnormalr)rrrrZ re_normalZ im_normalrararbrs         zPythonMPContext.isnormalFcCst|trdSt|drB|j\}}}}}t|r8|dkp>|tkSt|dr|j\}} |\} } } } | \}}}}| rz| dkp|tk}|r|r|dkp| tk}|o|S|o| tkSt|tjr|j \}}||dkS| |}t|dst|dr| ||St ddS)a  Return *True* if *x* is integer-valued; otherwise return *False*:: >>> from mpmath import * >>> isint(3) True >>> isint(mpf(3)) True >>> isint(3.2) False >>> isint(inf) False Optionally, Gaussian integers can be checked for:: >>> isint(3+0j) True >>> isint(3+2j) False >>> isint(3+2j, gaussian=True) True Trjrorzisint() needs a number as inputN) rrrrjrrrrZrrrisintr)rrZgaussianr{r|r}r~ZxvalrrZrsignZrmanZrexpZrbcZisignZimanZiexpZibcZre_isintZim_isintrrrararbrs*            zPythonMPContext.isintc Csv|j\}}g}g}|D]"}d} } t|dr6|j} nLt|drL|j\} } n6||}t|drh|j} nt|dr~|j\} } nt| r|r|r|t| | |t| | n,t| | fd|d\} } || || n.|r|t | | f|n|| || q|r"t| | } n|r0t | } || qt ||||} |rh| | t |||f} n | | } | S)aX Calculates a sum containing a finite number of terms (for infinite series, see :func:`~mpmath.nsum`). The terms will be converted to mpmath numbers. For len(terms) > 2, this function is generally faster and produces more accurate results than the builtin Python function :func:`sum`. >>> from mpmath import * >>> mp.dps = 15; mp.pretty = False >>> fsum([1, 2, 0.5, 7]) mpf('10.5') With squared=True each term is squared, and with absolute=True the absolute value of each term is used. rorjrrn )rrrrjrrr^appendr&rJr>r!r4rr) rZtermsabsoluteZsquaredrkrrrZtermZrevalZimvalrrararbfsum>sJ                zPythonMPContext.fsumNcCs|durt||}|j\}}g}g}t}|j|jf} |D]v\} } t| | vrX|| } t| | vrn|| } || d} || d} | r| r|t| j | j q8|| d}|| d}| r|r| j }| j \}}|rt |}|t|||t||q8| r8|r8| j \}}| j }|t|||t||q8|r|r| j \}}| j \}}|rft |}|t|||t t|||t|||t||q8t q8t |||}|r||t |||f}n ||}|S)a. Computes the dot product of the iterables `A` and `B`, .. math :: \sum_{k=0} A_k B_k. Alternatively, :func:`~mpmath.fdot` accepts a single iterable of pairs. In other words, ``fdot(A,B)`` and ``fdot(zip(A,B))`` are equivalent. The elements are automatically converted to mpmath numbers. With ``conjugate=True``, the elements in the second vector will be conjugated: .. math :: \sum_{k=0} A_k \overline{B_k} **Examples** >>> from mpmath import * >>> mp.dps = 15; mp.pretty = False >>> A = [2, 1.5, 3] >>> B = [1, -1, 2] >>> fdot(A, B) mpf('6.5') >>> list(zip(A, B)) [(2, 1), (1.5, -1), (3, 2)] >>> fdot(_) mpf('6.5') >>> A = [2, 1.5, 3j] >>> B = [1+j, 3, -1-j] >>> fdot(A, B) mpc(real='9.5', imag='-1.0') >>> fdot(A, B, conjugate=True) mpc(real='3.5', imag='-5.0') Nrjr)ziprrrrrrtrrr&rjrr#r^r4rr)rABrrkrrrZhasattr_rrrZa_realZb_realZ a_complexZ b_complexZavalZbreZbimZareZaimZbvalrrararbfdotzsX'               zPythonMPContext.fdotcs8fdd}jddtjd||_|S)aO Given a low-level mpf_ function, and optionally similar functions for mpc_ and mpi_, defines the function as a context method. It is assumed that the return type is the same as that of the input; the exception is that propagation from mpf to mpc is possible by raising ComplexResult. c st|jvr|}j\}}|rR|d|}d|vrFt|d}|d|}t|drz|j||WSt yj r |jt f||YS0nt|drƈ |j ||Stdt|fdS)Nrkrlrmrjrz %s of a %s)rtrrrrrsr rrrjrrrrrr^)rrzrkrmrmpc_fmpf_frrarbfs$         z/PythonMPContext._wrap_libmp_function..frpNzComputes the %s of x)rdr[__dict__rsrg)rr(r'Zmpi_fdocr)rar&rb_wrap_libmp_functions z$PythonMPContext._wrap_libmp_functioncs8|rfdd}n}tj|j|_t|||dS)Ncs\|jfdd|D}|j}z.|jd7_|g|Ri|}W||_n||_0| S)Ncsg|] }|qSrara).0rrrarb rzDPythonMPContext._wrap_specfun..f_wrapped..r)rrk)rrrzrkretvalr)r.rb f_wrappedsz0PythonMPContext._wrap_specfun..f_wrapped)r[r*rsrgsetattr)r_rr)wrapr2rar1rb _wrap_specfuns  zPythonMPContext._wrap_specfunc Cst|dr(|j\}}|tkr$|dfSnt|dr:|j}nt|tvrRt|dfSd}t|trj|\}}nFt|dr|j \}}n0t|t rd|vr| d\}}t|}t|}|dur||s||dfS| ||dfS| |}t|dr|j\}}|tkr,|dfSnt|dr$|j}n|dfS|\}}}} |r|d kr|rT| }|d krnt||>dfS|d krt|d | >}}| ||dfS||}|d fS|sd S|dfSdS)NrCrjZr/QUrorR)ror7)rrrrjrtrrrrvrrsplitrrr) rrrrrrr{r|r}r~rararb_convert_paramsX                      zPythonMPContext._convert_paramcCsB|\}}}}|r||S|tkr&|jS|tks6|tkr<|jS|jSr])rninfrrinfnan)rrr{r|r}r~rararb_mpf_mag7s zPythonMPContext._mpf_magcCst|dr||jSt|drh|j\}}|tkr<||S|tkrN||Sdt||||St|tr|rtt |S|j St|t j r|j \}}|rdtt |t|S|j S||}t|dst|dr||StddS)a Quick logarithmic magnitude estimate of a number. Returns an integer or infinity `m` such that `|x| <= 2^m`. It is not guaranteed that `m` is an optimal bound, but it will never be too large by more than 2 (and probably not more than 1). **Examples** >>> from mpmath import * >>> mp.pretty = True >>> mag(10), mag(10.0), mag(mpf(10)), int(ceil(log(10,2))) (4, 4, 4, 4) >>> mag(10j), mag(10+10j) (4, 5) >>> mag(0.01), int(ceil(log(0.01,2))) (-6, -6) >>> mag(0), mag(inf), mag(-inf), mag(nan) (-inf, +inf, +inf, nan) rjrrzrequires an mpf/mpcN)rrBrjrrrrrr5absr?rZrrrmagr)rrrrrrrararbrDAs,            zPythonMPContext.mag)T)F)FF)NF)NNr%)rdrerfrrrrr r rrkrlrrrrrrr r$r,rr5r>rBrDrarararbrEs,  2  ( / < W # 1 rroN)}Z libmp.backendrrZlibmprrrrrr r r r r rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrrZr[rrcrur\rirZ return_mpfZ return_mpcZ mpf_pow_samerrrrrrrrrrrrrrrrrrrComplexregisterReal ImportErrorrarararbse  D  ^5