gq>ddlmZmZddlmZddlmZddlmZddl m Z ddl m Z ddl mZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlm Z Gdde!Z"Gdde"eee e eeeeeeeeeZ#dS))gtlt)xrange)SpecialFunctions)RSCache)QuadratureMethods) LaplaceTransformInversionMethods)CalculusMethods)OptimizationMethods) ODEMethods) MatrixMethods)MatrixCalculusMethods)LinearAlgebraMethods)Eigen)IdentificationMethods)VisualizationMethods)libmpceZdZdS)ContextN)__name__ __module__ __qualname__K/var/www/html/ai-engine/env/lib/python3.11/site-packages/mpmath/ctx_base.pyrrsDrrceZdZejZejZdZdZdZdZ dZ dZ dZ dZ dZd Zd Zd Zd Zd Zd"dZd#dZdZd$dZd%dZd&dZdZdZdZdZdZeej Z!eej"Z"eej#Z#eej$Z$eej%Z%eej&Z'eej(Z)eej*Z+eej,Z-d'dZ.d'dZ/dZ0dZ1d Z2d!Z3dS)(StandardBaseContextci|_tj|tj|t j|t j|t j|tj|dSN)_aliasesr__init__rr r r r)ctxs rr"zStandardBaseContext.__init__*su !#&&&"3'''(1#666 %%%s#####rc |jD]5\}} t||t||&#t$rY2wxYwdSr )r!itemssetattrgetattrAttributeError)r#aliasvalues r _init_aliasesz!StandardBaseContext._init_aliases4sqL..00  LE5 UGC$7$78888!      sA A  A Fc&td|dS)NzWarning:)printr#msgs rwarnzStandardBaseContext.warn@s j#rc t|r ) ValueErrorr.s r bad_domainzStandardBaseContext.bad_domainCsoorc4t|dr|jS|S)Nreal)hasattrr5r#xs r_rezStandardBaseContext._reFs 1f   6Mrc>t|dr|jS|jS)Nimag)r6r;zeror7s r_imzStandardBaseContext._imKs" 1f   6Mxrc|Sr rr7s r _as_pointszStandardBaseContext._as_pointsPsrc .|| Sr convert)r#r8kwargss rfnegzStandardBaseContext.fnegSs Arc X||||zSr rAr#r8yrCs rfaddzStandardBaseContext.faddV!{{1~~ckk!nn,,rc X||||z Sr rArFs rfsubzStandardBaseContext.fsubYrIrc X||||zSr rArFs rfmulzStandardBaseContext.fmul\rIrc X||||z Sr rArFs rfdivzStandardBaseContext.fdiv_rIrc|r@|rtd|D|jStd|D|jS|rtd|D|jSt||jS)Nc3:K|]}t|dzVdSNabs.0r8s r z+StandardBaseContext.fsum..es,44!CFFAI444444rc34K|]}t|VdSr rTrVs rrXz+StandardBaseContext.fsum..fs(--1A------rc3 K|] }|dzV dSrRrrVs rrXz+StandardBaseContext.fsum..hs&++1++++++r)sumr<)r#argsabsolutesquareds rfsumzStandardBaseContext.fsumbs  9 @44t444ch???-----sx88 8  7++d+++SX66 64"""rNc|t||}|r(|jtfd|D|jStd|D|jS)Nc3:K|]\}}||zVdSr r)rWr8rGcfs rrXz+StandardBaseContext.fdot..ps300EQq""Q%%000000rc3&K|] \}}||zV dSr r)rWr8rGs rrXz+StandardBaseContext.fdot..rs*,,1!,,,,,,r)zipconjr[r<)r#xsys conjugaterbs @rfdotzStandardBaseContext.fdotksl >RB  8B0000R000#(;; ;,,,,,ch77 7rc(|j}|D]}||z}|Sr )one)r#r\prodargs rfprodzStandardBaseContext.fprodts(w  C CKDD rc >t|j||fi|dS)z6 Equivalent to ``print(nstr(x, n))``. N)r-nstr)r#r8nrCs rnprintzStandardBaseContext.nprintzs. hchq!&&v&&'''''rcX djz |}t|}t|krjS|ret |z}t|j|kr|jSt|j|krd|jSna#t$rTt|j r| fdcYSt|drfd|DcYSYnwxYw|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``. Ndrc0|Sr chop)ar#tols rz*StandardBaseContext.chop..s!S)9)9r__iter__c<g|]}|Srrw)rWryr#rzs r z,StandardBaseContext.chop..s'444QC((444r)epsrBrUr<_is_complex_typemaxr;r5mpc TypeError isinstancematrixapplyr6)r#r8rzabsxpart_tols` ` rrxzStandardBaseContext.chopsR ;cg+C 5 AAq66D1vv||x##A&& .sDH--qv;;))6Mqv;;))771af--- 5 5 5!SZ(( ;ww99999:::::q*%% 544444!444444 5 5 5 s$=C AC 2C 8D'D'&D'c&||}|#|!|d|j dzx}}||}n||}t||z }||krdSt|}t|}||kr||z }n||z }||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)rBldexpprecrU) r#strel_epsabs_epsdiffabssabsterrs ralmosteqzStandardBaseContext.almosteqsB KKNN ?w # !chYq[ 9 9 9Gg ?GG _G1Q3xx 7??41vv1vv $;;t)CCt)Cg~rct|dkstdt|zt|dkstdt|zd}d}t|dkr |d}n#t|dkr|d}|d}t|dkr|d}||||||}}}||z|ks Jd||kr|dkrgSt}n|dkrgSt}g}d}|} |||zz}|dz }|||r||nn1|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 %irrSz0dt is too small and would cause an infinite loop)lenrmpfrrappend) r#r\rydtbopresultirs rarangezStandardBaseContext.aranges@4yyA~~I!$ii()) )4yyA~~I!$ii()) )   t99>>QAA YY!^^QAQA t99>>aB771::swwqzz3772;;b12v{{{N{{{ q55Avv BBAvv B   BqDA FAr!Qxx  a       rc$t|dkrL||d||d}t|d}nzt|dkrHt|ddsJ|dj|dj}t|d}nt dt|z|dkrtdd|vs|dr\|dkr|gS|z ||dz z fd t|D}||d <n7|z ||z fd 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')] rrrrS_mpi_z*linspace expected 2 or 3 arguments, got %izn must be greater than 0endpointc g|] }|zz SrrrWrrysteps rr~z0StandardBaseContext.linspace..G!///4!///rc g|] }|zz Srrrs rr~z0StandardBaseContext.linspace..Krr) rrintr6ryrrr2r)r#r\rCrrrrGryrs @@rlinspacezStandardBaseContext.linspace s* t99>>Q  AQ  ADG AA YY!^^47G,, , , ,Q AQ ADG AAH!$ii()) ) q55788 8V##vj'9#Avv |#ESWWQU^^+D/////VAYY///AAbEEESWWQZZ'D/////VAYY///Arc :|j|fi||j|fi|fSr )cossinr#zrCs rcos_sinzStandardBaseContext.cos_sinNs5swq##F##WSWQ%9%9&%9%999rc :|j|fi||j|fi|fSr )cospisinpirs r cospi_sinpizStandardBaseContext.cospi_sinpiQs5sy%%f%%ysy'='=f'='===rc8td|dzzd|zzS)Nig?r)r)r#ps r_default_hyper_maxprecz*StandardBaseContext._default_hyper_maxprecTs!4!T'>AaC'(((rrc|j} d} ||zdz|_|j}|j}d}|D]]}||z }||zsL|rJ||} t || }||} | | z |jkrn|dz }^|| z } | | krn'| |ks|jrn|t |j| z }|||_S#||_wxYwN rr)rninfr<magr_fixed_precisionmin) r#terms check_stepr extraprecmax_magrktermterm_magsum_mag cancellations rsum_accuratelyz"StandardBaseContext.sum_accuratelyas"x I 9)+a/(H!EGGDIA N""#&774=="%gx"8"8"%''!**"X-88!EFAA&0 <//)++s/C+S<888 ' 9(CHHtCHOOOOs B>> 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 rA)r#r8rGs rpowerzStandardBaseContext.powers# {{1~~Q//rc,||Sr )zeta)r#rrs r _zeta_intzStandardBaseContext._zeta_intsxx{{rc$dgfd}|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 rc|dxxdz cc<dkrdz|i|S)Nrrz%maxcalls: function evaluated %i times) NoConvergence)r\rCNcounterr#fs rf_maxcalls_wrappedz8StandardBaseContext.maxcalls..f_maxcalls_wrappedsU AJJJ!OJJJqzA~~''(ORS(STTT1d%f%% %rr)r#rrrrs``` @rmaxcallszStandardBaseContext.maxcallss? # & & & & & & & & "!rcNifd}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 c|r$|t|f}n|}j}| vr |\}}||kr| S|i|}||f |<|Sr )tupler%r) r\rCkeyrcpreccvaluer*r#rf_caches rf_cachedz-StandardBaseContext.memoize..f_cacheds E&,,..1118Dg~~ ' vD=="7NAt&v&&E %=GCLLr)r__doc__)r#rrrs`` @rmemoizezStandardBaseContext.memoizesJ(       J9r)FF)NF)ror )NN)r)4rrrrr ComplexResultr"r+rverboser0r3r9r=r?rDrHrKrMrOr_rirnrsrxrrrrrr staticmethodgcd_gcd list_primesisprimebernfracmoebiusifac_ifaceulernum _eulernum stirling1 _stirling1 stirling2 _stirling2rrrrrrrrrrrs'M'M$$$G  ------------####8888 (((( """"H1111fGGGR,,,\:::>>>))) < " "D,u011Kl5=))G|EN++Hl5=))G L $ $E U^,,Ieo..Jeo..J8@000$"""0$$$$$rrN)$operatorrr libmp.backendrfunctions.functionsrfunctions.rszetarcalculus.quadraturer calculus.inverselaplacer calculus.calculusr calculus.optimizationr calculus.odesr matrices.matricesrmatrices.calculusrmatrices.linalgrmatrices.eigenridentificationr visualizationrrobjectrrrrrrs!!!!!!111111%%%%%%222222EEEEEE......666666%%%%%%,,,,,,444444111111!!!!!!111111//////     f   VVVVV' $ VVVVVr