[hq>SSKJrJr SSKJr SSKJr SSKJr SSK J r SSK J r SSK Jr SS KJr SS KJr SS KJr SS KJr SS KJr SSKJr SSKJr SSKJr SSKJ r "SS\!5r""SS\"\\\ \ \\\\\\\\\5r#g))gtlt)xrange)SpecialFunctions)RSCache)QuadratureMethods) LaplaceTransformInversionMethods)CalculusMethods)OptimizationMethods) ODEMethods) MatrixMethods)MatrixCalculusMethods)LinearAlgebraMethods)Eigen)IdentificationMethods)VisualizationMethods)libmpc\rSrSrSrg)ContextN)__name__ __module__ __qualname____firstlineno____static_attributes__rG/var/www/auris/envauris/lib/python3.13/site-packages/mpmath/ctx_base.pyrrsrrcZ\rSrSr\R r\R rSrSrSr Sr Sr Sr Sr SrS rS rS rS rS rSrS"SjrS#SjrSrS$SjrS%SjrS&SjrSrSrSrSrSr\ "\RB5r"\ "\RF5r#\ "\RH5r$\ "\RJ5r%\ "\RL5r&\ "\RN5r(\ "\RR5r*\ "\RV5r,\ "\RZ5r.S'Sjr/S'Sjr0Sr1Sr2Sr3S r4S!r5g)(StandardBaseContextc0Ul[R"U5 [R"U5 [R"U5 [ R"U5 [ R"U5 [R"U5 gN)_aliasesr__init__rr r r r)ctxs rr&StandardBaseContext.__init__*s] !!#&""3'(11#6  %s#rc URR5Hup[X[X55 M g![a M-f=fr$)r%itemssetattrgetattrAttributeError)r'aliasvalues r _init_aliases!StandardBaseContext._init_aliases4sCLL..0LE GC$781"  s; A A Fc[SU5 g)NzWarning:)printr'msgs rwarnStandardBaseContext.warn@s  j#rc[U5er$) ValueErrorr4s r bad_domainStandardBaseContext.bad_domainCs orc@[US5(a UR$U$)Nreal)hasattrr=r'xs r_reStandardBaseContext._reFs 1f  66MrcT[US5(a UR$UR$)Nimag)r>rDzeror?s r_imStandardBaseContext._imKs! 1f  66MxxrcU$r$rr?s r _as_pointsStandardBaseContext._as_pointsPsrc &URU5*$r$convert)r'r@kwargss rfnegStandardBaseContext.fnegSs Arc HURU5URU5-$r$rLr'r@yrNs rfaddStandardBaseContext.faddV{{1~ckk!n,,rc HURU5URU5- $r$rLrRs rfsubStandardBaseContext.fsubYrVrc HURU5URU5-$r$rLrRs rfmulStandardBaseContext.fmul\rVrc HURU5URU5- $r$rLrRs rfdivStandardBaseContext.fdiv_rVrcU(aAU(a[SU5UR5$[SU5UR5$U(a[SU5UR5$[XR5$)Nc3># UHn[U5S-v M g7fNabs.0r@s r +StandardBaseContext.fsum..es4t!CFAItsc38# UHn[U5v M g7fr$rdrfs rrhrifs-1Asc3*# UH oS-v M g7frbrrfs rrhrihs+d1ds)sumrE)r'argsabsolutesquareds rfsumStandardBaseContext.fsumbs_ 4t4chh??--sxx8 8 +d+SXX6 64""rNc^Ub [X5nU(a,URm[U4SjU5UR5$[SU5UR5$)Nc3>># UHupUT"U5-v M g7fr$r)rgr@rScfs rrh+StandardBaseContext.fdot..ps0REQ"Q%Rsc3.# UH upX-v M g7fr$r)rgr@rSs rrhrurs,s)zipconjrlrE)r'xsys conjugaterts @rfdotStandardBaseContext.fdotksK >RB B0R0#((; ;,,chh7 7rc8URnUHnX#-nM U$r$)one)r'rmprodargs rfprodStandardBaseContext.fprodts!wwC KD rc <[UR"X40UD65 g)z& Equivalent to ``print(nstr(x, n))``. N)r3nstr)r'r@nrNs rnprintStandardBaseContext.nprintzs chhq&v&'rc^^TcSTR-mTRU5n[U5n[U5T:a TR$TR U5(ai[ TUT-5n[UR 5U:a UR$[UR5U:aTRSUR 5$U$![as [UTR5(aURUU4Sj5s$[US5(a+UVs/sHnTRUT5PM Os snfsns$U$f=f)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``. drc(>TRUT5$r$)chop)ar'tols r*StandardBaseContext.chop..s!S)9r__iter__)epsrMrerE_is_complex_typemaxrDr=mpc TypeError isinstancematrixapplyr>r)r'r@rabsxpart_tolrs` ` rrStandardBaseContext.chops ;cgg+C 5 AAq6D1v|xx##A&&sDH-qvv;)66Mqvv;)771aff--   5!SZZ((ww9::q*%%234!QC(!44&  5s06C A C4C;E  E  D=< E  E cURU5nUc$Uc!URSUR*S-5=p4UcUnOUcUn[X- 5nXT::ag[U5n[U5nXg:aXW- nX:*$XV- nX:*$)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 rT)rMldexpprecre) r'strel_epsabs_epsdiffabssabsterrs ralmosteqStandardBaseContext.almosteqsB KKN ?w # !chhYq[ 9 9G ?G _G13x ?1v1v ;)C~)C~rcZ[U5S::d[S[U5-5e[U5S:d[S[U5-5eSnSn[U5S:XaUSnO[U5S:a USnUSn[U5S:XaUSnURU5URW5URU5p4nX#-U:wdS5eX$:aUS:a/$[nOUS:a/$[n/nSnUnX#U--nUS- nU"X5(aUR U5 OU$M0)a 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 %irrcz0dt is too small and would cause an infinite loop)lenrmpfrrappend) r'rmrdtbopresultirs rarangeStandardBaseContext.arangesJ@4yA~I!$i() )4yA~I!$i() )   t9>QA Y!^QAQA t9>aB771:swwqz3772;bv{NNN{ 5Av BAv B  qDA FA!xx a  rc[U5S:Xa7URUS5nURUS5n[US5nOi[U5S:XaC[USS5(deUSRnUSR n[US5nO[ S[U5-5eUS:a [S5eSU;d US(aWUS:XaURU5/$XC- URUS- 5- n[U5Vs/sH owU-U-PM nnXHS 'U$XC- URU5- n[U5Vs/sH owU-U-PM nnU$s snfs snf) aT ``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')] rrrrc_mpi_z*linspace expected 2 or 3 arguments, got %izn must be greater than 0endpoint) rrintr>rrrr9r) r'rmrNrrrsteprrSs rlinspaceStandardBaseContext.linspace se* t9>Q AQ ADG A Y!^47G,, ,,Q AQ ADG AH!$i() ) q578 8V#vj'9Av |#ESWWQU^+D%+AY/Y4!YA/bEESWWQZ'D%+AY/Y4!YA/ 00s E  E%c NUR"U40UD6UR"U40UD64$r$)cossinr'zrNs rcos_sinStandardBaseContext.cos_sinNs)wwq#F#SWWQ%9&%999rc NUR"U40UD6UR"U40UD64$r$)cospisinpirs r cospi_sinpiStandardBaseContext.cospi_sinpiQs)yy%f%syy'=f'===rc0[SUS--SU--5$)Nig?r)r)r'ps r_default_hyper_maxprec*StandardBaseContext._default_hyper_maxprecTs4!T'>AaC'((rcURnSnX4-S-UlURnURnSnU"5H]nXh- nXr-(dHU(aAURU5n [ XY5nURU5n X- UR:a O US- nM_ UW - n X:waO2X:dUR (aOU[ URU 5- nMUX0l$!X0lf=fN rr)rninfrEmagr_fixed_precisionmin) r'terms check_stepr extraprecmax_magrktermterm_magsum_mag cancellations rsum_accurately"StandardBaseContext.sum_accuratelyasxx I+a/((HH!GDIAN#&774="%g"8"%''!*"-8!FA$ '0 /+s/C/CS<88 '(HtH CC$$C,cURnSnX4-S-UlURnURnUnSnU"5H[n Xy-nX- n X-(dBURU 5n [ X[5nURXv- 5n U *UR:a O US- nM] UW - n X:waO2X:dUR (aOU[ URU 5- nMUX0l$!X0lf=fr)rrrrrrr)r'factorsrrrrrrrfactorrrrrs rmul_accurately"StandardBaseContext.mul_accurately}sxx I+a/((gg%iFKA!>> 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 rL)r'r@rSs rpowerStandardBaseContext.powers {{1~Q//rc$URU5$r$)zeta)r'rs r _zeta_intStandardBaseContext._zeta_intsxx{rc&^^^^S/mUUUU4SjnU$)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 rch>TS==S- ss'TST:aTRST-5eT"U0UD6$)Nrrz%maxcalls: function evaluated %i times) NoConvergence)rmrNNcounterr'fs rf_maxcalls_wrapped8StandardBaseContext.maxcalls..f_maxcalls_wrappedsC AJ!OJqzA~''(ORS(STTd%f% %rr)r'rrrrs``` @rmaxcallsStandardBaseContext.maxcallss # & & "!rcd^^^0mUUU4SjnTRUlTRUlU$)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>U(aU[UR554nOUnTRnUT ;aT UupEXC:aU7$T"U0UD6nX64T U'U$r$)tupler*r) rmrNkeyrcpreccvaluer/r'rf_caches rf_cached-StandardBaseContext.memoize..f_cachedsfE&,,.1188Dg~ ' ="7Nt&v&E =GCLLr)r__doc__)r'rrrs`` @rmemoizeStandardBaseContext.memoizes.( JJ99rr)FF)NF)r$)NN)r)6rrrrrr ComplexResultr&r0rverboser6r:rArFrIrOrTrXr[r^rpr|rrrrrrrrr staticmethodgcd_gcd list_primesisprimebernfracmoebiusifac_ifaceulernum _eulernum stirling1 _stirling1 stirling2 _stirling2rrrrrrrrrrr!r!sB''M''M$G  ----#8 ( "H1fGR,\:>)  "Du001K5==)GENN+H5==)G  $EU^^,Ieoo.Jeoo.J8@0$"0$rr!N)$operatorrr libmp.backendrfunctions.functionsrfunctions.rszetarcalculus.quadraturer calculus.inverselaplacer calculus.calculusr calculus.optimizationr calculus.odesr matrices.matricesrmatrices.calculusrmatrices.linalgrmatrices.eigenridentificationr visualizationrrobjectrr!rrrr(sv!1%2E.6%,41!1/ f V' $ Vr