a @sddlmZmZddlmZddlmZddlmZddl m Z ddl m Z ddl mZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlm Z Gddde!Z"Gddde"eee e eeeeeeeeeZ#dS))gtlt)xrange)SpecialFunctions)RSCache)QuadratureMethods) LaplaceTransformInversionMethods)CalculusMethods)OptimizationMethods) ODEMethods) MatrixMethods)MatrixCalculusMethods)LinearAlgebraMethods)Eigen)IdentificationMethods)VisualizationMethods)libmpc@s eZdZdS)ContextN)__name__ __module__ __qualname__rr_/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/mpmath/ctx_base.pyrsrc@speZdZejZejZddZddZdZdZ ddZ dd Z d d Z d d Z ddZddZddZddZddZddZd?ddZd@ddZdd ZdAd"d#ZdBd$d%ZdCd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zeej Z!eej"Z"eej#Z#eej$Z$eej%Z%eej&Z'eej(Z)eej*Z+eej,Z-dDd3d4Z.dEd5d6Z/d7d8Z0d9d:Z1d;d<Z2d=d>Z3dS)FStandardBaseContextcCsFi|_t|t|t|t|t|t|dSN)_aliasesr__init__rrr r r )ctxrrrr*s     zStandardBaseContext.__init__c CsB|jD]2\}}zt||t||Wq ty:Yq 0q dSr)ritemssetattrgetattrAttributeError)raliasvaluerrr _init_aliases4s  z!StandardBaseContext._init_aliasesFcCstd|dS)NzWarning:)printrmsgrrrwarn@szStandardBaseContext.warncCs t|dSr) ValueErrorr'rrr bad_domainCszStandardBaseContext.bad_domaincCst|dr|jS|S)Nreal)hasattrr,rxrrr_reFs zStandardBaseContext._recCst|dr|jS|jS)Nimag)r-r1zeror.rrr_imKs zStandardBaseContext._imcCs|Srrr.rrr _as_pointsPszStandardBaseContext._as_pointscKs || Srconvert)rr/kwargsrrrfnegSszStandardBaseContext.fnegcKs||||Srr5rr/yr7rrrfaddVszStandardBaseContext.faddcKs||||Srr5r9rrrfsubYszStandardBaseContext.fsubcKs||||Srr5r9rrrfmul\szStandardBaseContext.fmulcKs||||Srr5r9rrrfdiv_szStandardBaseContext.fdivcCsZ|r4|rtdd|D|jStdd|D|jS|rNtdd|D|jSt||jS)Ncss|]}t|dVqdSNabs.0r/rrr ez+StandardBaseContext.fsum..css|]}t|VqdSrrArCrrrrEfrFcss|]}|dVqdSr?rrCrrrrEhrF)sumr2)rargsabsoluteZsquaredrrrfsumbszStandardBaseContext.fsumNcsP|durt||}|r6|jtfdd|D|jStdd|D|jSdS)Nc3s|]\}}||VqdSrrrDr/r:cfrrrEprFz+StandardBaseContext.fdot..css|]\}}||VqdSrrrKrrrrErrF)zipZconjrGr2)rxsZys conjugaterrLrfdotks  zStandardBaseContext.fdotcCs|j}|D] }||9}q |Sr)one)rrHprodargrrrfprodts zStandardBaseContext.fprodcKst|j||fi|dS)z6 Equivalent to ``print(nstr(x, n))``. N)r&Znstr)rr/nr7rrrnprintzszStandardBaseContext.nprintcsdurdjzv|}t|}t|kr:jWS|rt|}t|j|krh|jWSt|j|krd|jWSWnXt yt |j r| fddYSt |dr܇fdd|DYSYn0|S) a Chops off small real or imaginary parts, or converts numbers close to zero to exact zeros. The input can be a single number or an iterable:: >>> from mpmath import * >>> mp.dps = 15; mp.pretty = False >>> chop(5+1e-10j, tol=1e-9) mpf('5.0') >>> nprint(chop([1.0, 1e-20, 3+1e-18j, -4, 2])) [1.0, 0.0, 3.0, -4.0, 2.0] The tolerance defaults to ``100*eps``. Ndrcs |Srchop)artolrrrFz*StandardBaseContext.chop..__iter__csg|]}|qSrrZ)rDr\r]rr rFz,StandardBaseContext.chop..)Zepsr6rBr2Z_is_complex_typemaxr1r,Zmpc TypeError isinstanceZmatrixapplyr-)rr/r^ZabsxZpart_tolrr]rr[s&       zStandardBaseContext.chopc Cs||}|dur2|dur2|d|j d}}|dur@|}n |durL|}t||}||krddSt|}t|}||kr||}n||}||kS)a Determine whether the difference between `s` and `t` is smaller than a given epsilon, either relatively or absolutely. Both a maximum relative difference and a maximum difference ('epsilons') may be specified. The absolute difference is defined as `|s-t|` and the relative difference is defined as `|s-t|/\max(|s|, |t|)`. If only one epsilon is given, both are set to the same value. If none is given, both epsilons are set to `2^{-p+m}` where `p` is the current working precision and `m` is a small integer. The default setting typically allows :func:`~mpmath.almosteq` to be used to check for mathematical equality in the presence of small rounding errors. **Examples** >>> from mpmath import * >>> mp.dps = 15 >>> almosteq(3.141592653589793, 3.141592653589790) True >>> almosteq(3.141592653589793, 3.141592653589700) False >>> almosteq(3.141592653589793, 3.141592653589700, 1e-10) True >>> almosteq(1e-20, 2e-20) True >>> almosteq(1e-20, 2e-20, rel_eps=0, abs_eps=0) False NrT)r6ldexpprecrB) rstZrel_epsZabs_epsdiffZabssZabsterrrrralmosteqs !   zStandardBaseContext.almosteqc Gs(t|dkstdt|t|dks8tdt|d}d}t|dkrV|d}nt|dkrr|d}|d}t|dkr|d}||||||}}}|||ksJd||kr|dkrgSt}n|dkrgSt}g}d}|}|||}|d7}|||r$||qq$q|S)aa This is a generalized version of Python's :func:`~mpmath.range` function that accepts fractional endpoints and step sizes and returns a list of ``mpf`` instances. Like :func:`~mpmath.range`, :func:`~mpmath.arange` can be called with 1, 2 or 3 arguments: ``arange(b)`` `[0, 1, 2, \ldots, x]` ``arange(a, b)`` `[a, a+1, a+2, \ldots, x]` ``arange(a, b, h)`` `[a, a+h, a+h, \ldots, x]` where `b-1 \le x < b` (in the third case, `b-h \le x < b`). Like Python's :func:`~mpmath.range`, the endpoint is not included. To produce ranges where the endpoint is included, :func:`~mpmath.linspace` is more convenient. **Examples** >>> from mpmath import * >>> mp.dps = 15; mp.pretty = False >>> arange(4) [mpf('0.0'), mpf('1.0'), mpf('2.0'), mpf('3.0')] >>> arange(1, 2, 0.25) [mpf('1.0'), mpf('1.25'), mpf('1.5'), mpf('1.75')] >>> arange(1, -1, -0.75) [mpf('1.0'), mpf('0.25'), mpf('-0.5')] z+arange expected at most 3 arguments, got %irz+arange expected at least 1 argument, got %irr@z0dt is too small and would cause an infinite loop)lenrcmpfrrappend) rrHr\dtbopresultirjrrrarangesF      "   zStandardBaseContext.arangecs t|dkr6||d||d}t|d}nPt|dkrvt|ddsTJ|dj|dj}t|d}ntdt||dkrtdd|vs|dr|dkr|gS|||dfd d t|D}||d <n*|||fd d t|D}|S) a ``linspace(a, b, n)`` returns a list of `n` evenly spaced samples from `a` to `b`. The syntax ``linspace(mpi(a,b), n)`` is also valid. This function is often more convenient than :func:`~mpmath.arange` for partitioning an interval into subintervals, since the endpoint is included:: >>> from mpmath import * >>> mp.dps = 15; mp.pretty = False >>> linspace(1, 4, 4) [mpf('1.0'), mpf('2.0'), mpf('3.0'), mpf('4.0')] You may also provide the keyword argument ``endpoint=False``:: >>> linspace(1, 4, 4, endpoint=False) [mpf('1.0'), mpf('1.75'), mpf('2.5'), mpf('3.25')] rnrrr@Z_mpi_z*linspace expected 2 or 3 arguments, got %izn must be greater than 0Zendpointcsg|]}|qSrrrDrvr\steprrraGrFz0StandardBaseContext.linspace..csg|]}|qSrrrxryrrraKrF) rorpintr-r\rsrcr*r)rrHr7rsrWr:rryrlinspace s.      zStandardBaseContext.linspacecKs$|j|fi||j|fi|fSr)cossinrzr7rrrcos_sinNszStandardBaseContext.cos_sincKs$|j|fi||j|fi|fSr)ZcospiZsinpirrrr cospi_sinpiQszStandardBaseContext.cospi_sinpicCstd|dd|S)Nig?rf)r|)rprrr_default_hyper_maxprecTsz*StandardBaseContext._default_hyper_maxprecrc Cs|j}zd}||d|_|j}|j}d}|D]P}||7}||sx|rx||} t|| }||} | | |jkrxq|d7}q0|| } | | krq| |ks|jrq|t|j| 7}q |W||_S||_0dSN rr)rhninfr2magrb_fixed_precisionmin) rZterms check_steprh extraprecmax_magriktermterm_magsum_mag cancellationrrrsum_accuratelyas4      z"StandardBaseContext.sum_accuratelycCs|j}zd}||d|_|j}|j}|}d}|D]V} || 9}| |} ||s|| } t|| }|||} | |jkrq|d7}q4|| } | | krq| |ks|jrq|t|j| 7}q |W||_S||_0dSr)rhrrRrrbrr)rZfactorsrrhrrrRrirZfactorrrrrrrrmul_accurately}s8     z"StandardBaseContext.mul_accuratelycCs||||S)aConverts `x` and `y` to mpmath numbers and evaluates `x^y = \exp(y \log(x))`:: >>> from mpmath import * >>> mp.dps = 30; mp.pretty = True >>> power(2, 0.5) 1.41421356237309504880168872421 This shows the leading few digits of a large Mersenne prime (performing the exact calculation ``2**43112609-1`` and displaying the result in Python would be very slow):: >>> power(2, 43112609)-1 3.16470269330255923143453723949e+12978188 r5)rr/r:rrrpowerszStandardBaseContext.powercCs ||Sr)zeta)rrWrrr _zeta_intszStandardBaseContext._zeta_intcsdgfdd}|S)a Return a wrapped copy of *f* that raises ``NoConvergence`` when *f* has been called more than *N* times:: >>> from mpmath import * >>> mp.dps = 15 >>> f = maxcalls(sin, 10) >>> print(sum(f(n) for n in range(10))) 1.95520948210738 >>> f(10) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... NoConvergence: maxcalls: function evaluated 10 times rcs8dd7<dkr*d|i|S)Nrrz%maxcalls: function evaluated %i times) NoConvergence)rHr7Ncounterrfrrf_maxcalls_wrappeds z8StandardBaseContext.maxcalls..f_maxcalls_wrappedr)rrrrrrrmaxcallsszStandardBaseContext.maxcallscs(ifdd}j|_j|_|S)a Return a wrapped copy of *f* that caches computed values, i.e. a memoized copy of *f*. Values are only reused if the cached precision is equal to or higher than the working precision:: >>> from mpmath import * >>> mp.dps = 15; mp.pretty = True >>> f = memoize(maxcalls(sin, 1)) >>> f(2) 0.909297426825682 >>> f(2) 0.909297426825682 >>> mp.dps = 25 >>> f(2) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... NoConvergence: maxcalls: function evaluated 1 times cs`|r|t|f}n|}j}|vrB|\}}||krB| S|i|}||f|<|Sr)tuplerrh)rHr7keyrhZcprecZcvaluer$rrZf_cacherrf_cacheds  z-StandardBaseContext.memoize..f_cached)r__doc__)rrrrrrmemoizes  zStandardBaseContext.memoize)FF)NF)rV)N)NN)r)r)4rrrrrZ ComplexResultrr%rverboser)r+r0r3r4r8r;r<r=r>rJrQrUrXr[rmrwr}rrr staticmethodgcdZ_gcdZ list_primesZisprimeZbernfracZmoebiusZifacZ_ifacZeulernumZ _eulernumZ stirling1Z _stirling1Z stirling2Z _stirling2rrrrrrrrrrrsT    $ 3I.           rN)$operatorrrZ libmp.backendrZfunctions.functionsrZfunctions.rszetarZcalculus.quadraturerZcalculus.inverselaplacer Zcalculus.calculusr Zcalculus.optimizationr Z calculus.odesr Zmatrices.matricesr Zmatrices.calculusrZmatrices.linalgrZmatrices.eigenrZidentificationrZ visualizationrrobjectrrrrrrs>